import { Message, proto3, type BinaryReadOptions, type FieldList, type JsonReadOptions, type JsonValue, type PartialMessage, type PlainMessage } from '@bufbuild/protobuf';
import { Filter, VEvent, VGtid } from './binlogdata_pb.js';
import { BindVariable, BoundQuery, ExecuteOptions, Field, QueryResult, QueryWarning, ResultWithError, Target } from './query_pb.js';
import { TabletAlias, TabletType } from './topodata_pb.js';
import { CallerID, RPCError } from './vtrpc_pb.js';
/**
 * TransactionMode controls the execution of distributed transaction
 * across multiple shards.
 *
 * @generated from enum vtgate.TransactionMode
 */
export declare enum TransactionMode {
    /**
     * UNSPECIFIED uses the transaction mode set by the VTGate flag 'transaction_mode'.
     *
     * @generated from enum value: UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * SINGLE disallows distributed transactions.
     *
     * @generated from enum value: SINGLE = 1;
     */
    SINGLE = 1,
    /**
     * MULTI allows distributed transactions with best effort commit.
     *
     * @generated from enum value: MULTI = 2;
     */
    MULTI = 2,
    /**
     * TWOPC is for distributed transactions with atomic commits.
     *
     * @generated from enum value: TWOPC = 3;
     */
    TWOPC = 3
}
/**
 * CommitOrder is used to designate which of the ShardSessions
 * get used for transactions.
 *
 * @generated from enum vtgate.CommitOrder
 */
export declare enum CommitOrder {
    /**
     * NORMAL is the default commit order.
     *
     * @generated from enum value: NORMAL = 0;
     */
    NORMAL = 0,
    /**
     * PRE is used to designate pre_sessions.
     *
     * @generated from enum value: PRE = 1;
     */
    PRE = 1,
    /**
     * POST is used to designate post_sessions.
     *
     * @generated from enum value: POST = 2;
     */
    POST = 2,
    /**
     * AUTOCOMMIT is used to run the statement as autocommitted transaction.
     *
     * @generated from enum value: AUTOCOMMIT = 3;
     */
    AUTOCOMMIT = 3
}
/**
 * Session objects are exchanged like cookies through various
 * calls to VTGate. The behavior differs between V2 & V3 APIs.
 * V3 APIs are Execute, ExecuteBatch and StreamExecute. All
 * other APIs are V2. For the V3 APIs, the session
 * must be sent with every call to Execute or ExecuteBatch.
 * For the V2 APIs, Begin does not accept a session. It instead
 * returns a brand new one with in_transaction set to true.
 * After a call to Commit or Rollback, the session can be
 * discarded. If you're not in a transaction, Session is
 * an optional parameter for the V2 APIs.
 *
 * @generated from message vtgate.Session
 */
export declare class Session extends Message<Session> {
    /**
     * in_transaction is set to true if the session is in a transaction.
     *
     * @generated from field: bool in_transaction = 1;
     */
    inTransaction: boolean;
    /**
     * shard_sessions keep track of per-shard transaction info.
     *
     * @generated from field: repeated vtgate.Session.ShardSession shard_sessions = 2;
     */
    shardSessions: Session_ShardSession[];
    /**
     * autocommit specifies if the session is in autocommit mode.
     * This is used only for V3.
     *
     * @generated from field: bool autocommit = 4;
     */
    autocommit: boolean;
    /**
     * target_string is the target expressed as a string. Valid
     * names are: keyspace:shard@target, keyspace@target or @target.
     * This is used only for V3.
     *
     * @generated from field: string target_string = 5;
     */
    targetString: string;
    /**
     * options is used only for V3.
     *
     * @generated from field: query.ExecuteOptions options = 6;
     */
    options?: ExecuteOptions;
    /**
     * transaction_mode specifies the current transaction mode.
     *
     * @generated from field: vtgate.TransactionMode transaction_mode = 7;
     */
    transactionMode: TransactionMode;
    /**
     * warnings contains non-fatal warnings from the previous query
     *
     * @generated from field: repeated query.QueryWarning warnings = 8;
     */
    warnings: QueryWarning[];
    /**
     * pre_sessions contains sessions that have to be committed first.
     *
     * @generated from field: repeated vtgate.Session.ShardSession pre_sessions = 9;
     */
    preSessions: Session_ShardSession[];
    /**
     * post_sessions contains sessions that have to be committed last.
     *
     * @generated from field: repeated vtgate.Session.ShardSession post_sessions = 10;
     */
    postSessions: Session_ShardSession[];
    /**
     * last_insert_id keeps track of the last seen insert_id for this session
     *
     * @generated from field: uint64 last_insert_id = 11;
     */
    lastInsertId: bigint;
    /**
     * found_rows keeps track of how many rows the last query returned
     *
     * @generated from field: uint64 found_rows = 12;
     */
    foundRows: bigint;
    /**
     * user_defined_variables contains all the @variables defined for this session
     *
     * @generated from field: map<string, query.BindVariable> user_defined_variables = 13;
     */
    userDefinedVariables: {
        [key: string]: BindVariable;
    };
    /**
     * system_variables keeps track of all session variables set for this connection
     * TODO: systay should we keep this so we can apply it ordered?
     *
     * @generated from field: map<string, string> system_variables = 14;
     */
    systemVariables: {
        [key: string]: string;
    };
    /**
     * row_count keeps track of the last seen rows affected for this session
     *
     * @generated from field: int64 row_count = 15;
     */
    rowCount: bigint;
    /**
     * Stores savepoint and release savepoint calls inside a transaction
     * and is reset once transaction is committed or rolled back.
     *
     * @generated from field: repeated string savepoints = 16;
     */
    savepoints: string[];
    /**
     * in_reserved_conn is set to true if the session should be using reserved connections.
     *
     * @generated from field: bool in_reserved_conn = 17;
     */
    inReservedConn: boolean;
    /**
     * lock_session keep tracks of shard on which the lock query is sent.
     *
     * @generated from field: vtgate.Session.ShardSession lock_session = 18;
     */
    lockSession?: Session_ShardSession;
    /**
     * last_lock_heartbeat keep tracks of when last lock heartbeat was sent.
     *
     * @generated from field: int64 last_lock_heartbeat = 19;
     */
    lastLockHeartbeat: bigint;
    /**
     * read_after_write tracks the ReadAfterWrite settings for this session.
     *
     * @generated from field: vtgate.ReadAfterWrite read_after_write = 20;
     */
    readAfterWrite?: ReadAfterWrite;
    /**
     * DDL strategy
     *
     * @generated from field: string DDLStrategy = 21;
     */
    DDLStrategy: string;
    /**
     * Session UUID
     *
     * @generated from field: string SessionUUID = 22;
     */
    SessionUUID: string;
    /**
     * enable_system_settings defines if we can use reserved connections.
     *
     * @generated from field: bool enable_system_settings = 23;
     */
    enableSystemSettings: boolean;
    /**
     * @generated from field: map<string, int64> advisory_lock = 24;
     */
    advisoryLock: {
        [key: string]: bigint;
    };
    /**
     * query_timeout is the maximum amount of time a query is permitted to run
     *
     * @generated from field: int64 query_timeout = 25;
     */
    queryTimeout: bigint;
    /**
     * @generated from field: map<string, vtgate.PrepareData> prepare_statement = 26;
     */
    prepareStatement: {
        [key: string]: PrepareData;
    };
    /**
     * MigrationContext
     *
     * @generated from field: string migration_context = 27;
     */
    migrationContext: string;
    constructor(data?: PartialMessage<Session>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.Session";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Session;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Session;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Session;
    static equals(a: Session | PlainMessage<Session> | undefined, b: Session | PlainMessage<Session> | undefined): boolean;
}
/**
 * @generated from message vtgate.Session.ShardSession
 */
export declare class Session_ShardSession extends Message<Session_ShardSession> {
    /**
     * @generated from field: query.Target target = 1;
     */
    target?: Target;
    /**
     * @generated from field: int64 transaction_id = 2;
     */
    transactionId: bigint;
    /**
     * @generated from field: topodata.TabletAlias tablet_alias = 3;
     */
    tabletAlias?: TabletAlias;
    /**
     * reserved connection if a dedicated connection is needed
     *
     * @generated from field: int64 reserved_id = 4;
     */
    reservedId: bigint;
    /**
     * @generated from field: bool vindex_only = 5;
     */
    vindexOnly: boolean;
    constructor(data?: PartialMessage<Session_ShardSession>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.Session.ShardSession";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Session_ShardSession;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Session_ShardSession;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Session_ShardSession;
    static equals(a: Session_ShardSession | PlainMessage<Session_ShardSession> | undefined, b: Session_ShardSession | PlainMessage<Session_ShardSession> | undefined): boolean;
}
/**
 * PrepareData keeps the prepared statement and other information related for execution of it.
 *
 * @generated from message vtgate.PrepareData
 */
export declare class PrepareData extends Message<PrepareData> {
    /**
     * @generated from field: string prepare_statement = 1;
     */
    prepareStatement: string;
    /**
     * @generated from field: int32 params_count = 2;
     */
    paramsCount: number;
    constructor(data?: PartialMessage<PrepareData>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.PrepareData";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PrepareData;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PrepareData;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PrepareData;
    static equals(a: PrepareData | PlainMessage<PrepareData> | undefined, b: PrepareData | PlainMessage<PrepareData> | undefined): boolean;
}
/**
 * ReadAfterWrite contains information regarding gtid set and timeout
 * Also if the gtid information needs to be passed to client.
 *
 * @generated from message vtgate.ReadAfterWrite
 */
export declare class ReadAfterWrite extends Message<ReadAfterWrite> {
    /**
     * @generated from field: string read_after_write_gtid = 1;
     */
    readAfterWriteGtid: string;
    /**
     * @generated from field: double read_after_write_timeout = 2;
     */
    readAfterWriteTimeout: number;
    /**
     * @generated from field: bool session_track_gtids = 3;
     */
    sessionTrackGtids: boolean;
    constructor(data?: PartialMessage<ReadAfterWrite>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.ReadAfterWrite";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ReadAfterWrite;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ReadAfterWrite;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ReadAfterWrite;
    static equals(a: ReadAfterWrite | PlainMessage<ReadAfterWrite> | undefined, b: ReadAfterWrite | PlainMessage<ReadAfterWrite> | undefined): boolean;
}
/**
 * ExecuteRequest is the payload to Execute.
 *
 * @generated from message vtgate.ExecuteRequest
 */
export declare class ExecuteRequest extends Message<ExecuteRequest> {
    /**
     * caller_id identifies the caller. This is the effective caller ID,
     * set by the application to further identify the caller.
     *
     * @generated from field: vtrpc.CallerID caller_id = 1;
     */
    callerId?: CallerID;
    /**
     * session carries the session state.
     *
     * @generated from field: vtgate.Session session = 2;
     */
    session?: Session;
    /**
     * query is the query and bind variables to execute.
     *
     * @generated from field: query.BoundQuery query = 3;
     */
    query?: BoundQuery;
    constructor(data?: PartialMessage<ExecuteRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.ExecuteRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecuteRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecuteRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecuteRequest;
    static equals(a: ExecuteRequest | PlainMessage<ExecuteRequest> | undefined, b: ExecuteRequest | PlainMessage<ExecuteRequest> | undefined): boolean;
}
/**
 * ExecuteResponse is the returned value from Execute.
 *
 * @generated from message vtgate.ExecuteResponse
 */
export declare class ExecuteResponse extends Message<ExecuteResponse> {
    /**
     * error contains an application level error if necessary. Note the
     * session may have changed, even when an error is returned (for
     * instance if a database integrity error happened).
     *
     * @generated from field: vtrpc.RPCError error = 1;
     */
    error?: RPCError;
    /**
     * session is the updated session information.
     *
     * @generated from field: vtgate.Session session = 2;
     */
    session?: Session;
    /**
     * result contains the query result, only set if error is unset.
     *
     * @generated from field: query.QueryResult result = 3;
     */
    result?: QueryResult;
    constructor(data?: PartialMessage<ExecuteResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.ExecuteResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecuteResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecuteResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecuteResponse;
    static equals(a: ExecuteResponse | PlainMessage<ExecuteResponse> | undefined, b: ExecuteResponse | PlainMessage<ExecuteResponse> | undefined): boolean;
}
/**
 * ExecuteBatchRequest is the payload to ExecuteBatch.
 *
 * @generated from message vtgate.ExecuteBatchRequest
 */
export declare class ExecuteBatchRequest extends Message<ExecuteBatchRequest> {
    /**
     * caller_id identifies the caller. This is the effective caller ID,
     * set by the application to further identify the caller.
     *
     * @generated from field: vtrpc.CallerID caller_id = 1;
     */
    callerId?: CallerID;
    /**
     * session carries the session state.
     *
     * @generated from field: vtgate.Session session = 2;
     */
    session?: Session;
    /**
     * queries is a list of query and bind variables to execute.
     *
     * @generated from field: repeated query.BoundQuery queries = 3;
     */
    queries: BoundQuery[];
    constructor(data?: PartialMessage<ExecuteBatchRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.ExecuteBatchRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecuteBatchRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecuteBatchRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecuteBatchRequest;
    static equals(a: ExecuteBatchRequest | PlainMessage<ExecuteBatchRequest> | undefined, b: ExecuteBatchRequest | PlainMessage<ExecuteBatchRequest> | undefined): boolean;
}
/**
 * ExecuteBatchResponse is the returned value from ExecuteBatch.
 *
 * @generated from message vtgate.ExecuteBatchResponse
 */
export declare class ExecuteBatchResponse extends Message<ExecuteBatchResponse> {
    /**
     * error contains an application level error if necessary. Note the
     * session may have changed, even when an error is returned (for
     * instance if a database integrity error happened).
     *
     * @generated from field: vtrpc.RPCError error = 1;
     */
    error?: RPCError;
    /**
     * session is the updated session information.
     *
     * @generated from field: vtgate.Session session = 2;
     */
    session?: Session;
    /**
     * results contains the query results, only set if application level error is unset.
     *
     * @generated from field: repeated query.ResultWithError results = 3;
     */
    results: ResultWithError[];
    constructor(data?: PartialMessage<ExecuteBatchResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.ExecuteBatchResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecuteBatchResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecuteBatchResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecuteBatchResponse;
    static equals(a: ExecuteBatchResponse | PlainMessage<ExecuteBatchResponse> | undefined, b: ExecuteBatchResponse | PlainMessage<ExecuteBatchResponse> | undefined): boolean;
}
/**
 * StreamExecuteRequest is the payload to StreamExecute.
 *
 * @generated from message vtgate.StreamExecuteRequest
 */
export declare class StreamExecuteRequest extends Message<StreamExecuteRequest> {
    /**
     * caller_id identifies the caller. This is the effective caller ID,
     * set by the application to further identify the caller.
     *
     * @generated from field: vtrpc.CallerID caller_id = 1;
     */
    callerId?: CallerID;
    /**
     * query is the query and bind variables to execute.
     *
     * @generated from field: query.BoundQuery query = 2;
     */
    query?: BoundQuery;
    /**
     * session carries the session state.
     *
     * @generated from field: vtgate.Session session = 6;
     */
    session?: Session;
    constructor(data?: PartialMessage<StreamExecuteRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.StreamExecuteRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamExecuteRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamExecuteRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamExecuteRequest;
    static equals(a: StreamExecuteRequest | PlainMessage<StreamExecuteRequest> | undefined, b: StreamExecuteRequest | PlainMessage<StreamExecuteRequest> | undefined): boolean;
}
/**
 * StreamExecuteResponse is the returned value from StreamExecute.
 * The session is currently not returned because StreamExecute is
 * not expected to modify it.
 *
 * @generated from message vtgate.StreamExecuteResponse
 */
export declare class StreamExecuteResponse extends Message<StreamExecuteResponse> {
    /**
     * result contains the result data.
     * The first value contains only Fields information.
     * The next values contain the actual rows, a few values per result.
     *
     * @generated from field: query.QueryResult result = 1;
     */
    result?: QueryResult;
    /**
     * session is the updated session information.
     *
     * @generated from field: vtgate.Session session = 2;
     */
    session?: Session;
    constructor(data?: PartialMessage<StreamExecuteResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.StreamExecuteResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamExecuteResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamExecuteResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamExecuteResponse;
    static equals(a: StreamExecuteResponse | PlainMessage<StreamExecuteResponse> | undefined, b: StreamExecuteResponse | PlainMessage<StreamExecuteResponse> | undefined): boolean;
}
/**
 * ResolveTransactionRequest is the payload to ResolveTransaction.
 *
 * @generated from message vtgate.ResolveTransactionRequest
 */
export declare class ResolveTransactionRequest extends Message<ResolveTransactionRequest> {
    /**
     * caller_id identifies the caller. This is the effective caller ID,
     * set by the application to further identify the caller.
     *
     * @generated from field: vtrpc.CallerID caller_id = 1;
     */
    callerId?: CallerID;
    /**
     * dtid is the dtid of the transaction to be resolved.
     *
     * @generated from field: string dtid = 2;
     */
    dtid: string;
    constructor(data?: PartialMessage<ResolveTransactionRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.ResolveTransactionRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResolveTransactionRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResolveTransactionRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResolveTransactionRequest;
    static equals(a: ResolveTransactionRequest | PlainMessage<ResolveTransactionRequest> | undefined, b: ResolveTransactionRequest | PlainMessage<ResolveTransactionRequest> | undefined): boolean;
}
/**
 * ResolveTransactionResponse is the returned value from Rollback.
 *
 * @generated from message vtgate.ResolveTransactionResponse
 */
export declare class ResolveTransactionResponse extends Message<ResolveTransactionResponse> {
    constructor(data?: PartialMessage<ResolveTransactionResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.ResolveTransactionResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResolveTransactionResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResolveTransactionResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResolveTransactionResponse;
    static equals(a: ResolveTransactionResponse | PlainMessage<ResolveTransactionResponse> | undefined, b: ResolveTransactionResponse | PlainMessage<ResolveTransactionResponse> | undefined): boolean;
}
/**
 * @generated from message vtgate.VStreamFlags
 */
export declare class VStreamFlags extends Message<VStreamFlags> {
    /**
     * align streams
     *
     * @generated from field: bool minimize_skew = 1;
     */
    minimizeSkew: boolean;
    /**
     * how often heartbeats must be sent when idle (seconds)
     *
     * @generated from field: uint32 heartbeat_interval = 2;
     */
    heartbeatInterval: number;
    /**
     * stop streams on a reshard (journal event)
     *
     * @generated from field: bool stop_on_reshard = 3;
     */
    stopOnReshard: boolean;
    /**
     * if specified, these cells (comma-separated) are used to pick source tablets from.
     * defaults to the cell of the vtgate serving the VStream API.
     *
     * @generated from field: string cells = 4;
     */
    cells: string;
    /**
     * @generated from field: string cell_preference = 5;
     */
    cellPreference: string;
    /**
     * @generated from field: string tablet_order = 6;
     */
    tabletOrder: string;
    /**
     * When set, all new row events from the `heartbeat` table, for all shards, in the sidecardb will be streamed.
     *
     * @generated from field: bool stream_keyspace_heartbeats = 7;
     */
    streamKeyspaceHeartbeats: boolean;
    /**
     * Include reshard journal events in the stream.
     *
     * @generated from field: bool include_reshard_journal_events = 8;
     */
    includeReshardJournalEvents: boolean;
    constructor(data?: PartialMessage<VStreamFlags>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.VStreamFlags";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VStreamFlags;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VStreamFlags;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VStreamFlags;
    static equals(a: VStreamFlags | PlainMessage<VStreamFlags> | undefined, b: VStreamFlags | PlainMessage<VStreamFlags> | undefined): boolean;
}
/**
 * VStreamRequest is the payload for VStream.
 *
 * @generated from message vtgate.VStreamRequest
 */
export declare class VStreamRequest extends Message<VStreamRequest> {
    /**
     * @generated from field: vtrpc.CallerID caller_id = 1;
     */
    callerId?: CallerID;
    /**
     * @generated from field: topodata.TabletType tablet_type = 2;
     */
    tabletType: TabletType;
    /**
     * position specifies the starting point of the bin log positions
     * as well as the keyspace-shards to pull events from.
     * position is of the form 'ks1:0@MySQL56/<mysql_pos>|ks2:-80@MySQL56/<mysql_pos>'.
     *
     * @generated from field: binlogdata.VGtid vgtid = 3;
     */
    vgtid?: VGtid;
    /**
     * @generated from field: binlogdata.Filter filter = 4;
     */
    filter?: Filter;
    /**
     * @generated from field: vtgate.VStreamFlags flags = 5;
     */
    flags?: VStreamFlags;
    constructor(data?: PartialMessage<VStreamRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.VStreamRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VStreamRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VStreamRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VStreamRequest;
    static equals(a: VStreamRequest | PlainMessage<VStreamRequest> | undefined, b: VStreamRequest | PlainMessage<VStreamRequest> | undefined): boolean;
}
/**
 * VStreamResponse is streamed by VStream.
 *
 * @generated from message vtgate.VStreamResponse
 */
export declare class VStreamResponse extends Message<VStreamResponse> {
    /**
     * @generated from field: repeated binlogdata.VEvent events = 1;
     */
    events: VEvent[];
    constructor(data?: PartialMessage<VStreamResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.VStreamResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VStreamResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VStreamResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VStreamResponse;
    static equals(a: VStreamResponse | PlainMessage<VStreamResponse> | undefined, b: VStreamResponse | PlainMessage<VStreamResponse> | undefined): boolean;
}
/**
 * PrepareRequest is the payload to Prepare.
 *
 * @generated from message vtgate.PrepareRequest
 */
export declare class PrepareRequest extends Message<PrepareRequest> {
    /**
     * caller_id identifies the caller. This is the effective caller ID,
     * set by the application to further identify the caller.
     *
     * @generated from field: vtrpc.CallerID caller_id = 1;
     */
    callerId?: CallerID;
    /**
     * session carries the session state.
     *
     * @generated from field: vtgate.Session session = 2;
     */
    session?: Session;
    /**
     * query is the query and bind variables to execute.
     *
     * @generated from field: query.BoundQuery query = 3;
     */
    query?: BoundQuery;
    constructor(data?: PartialMessage<PrepareRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.PrepareRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PrepareRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PrepareRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PrepareRequest;
    static equals(a: PrepareRequest | PlainMessage<PrepareRequest> | undefined, b: PrepareRequest | PlainMessage<PrepareRequest> | undefined): boolean;
}
/**
 * PrepareResponse is the returned value from Prepare.
 *
 * @generated from message vtgate.PrepareResponse
 */
export declare class PrepareResponse extends Message<PrepareResponse> {
    /**
     * error contains an application level error if necessary. Note the
     * session may have changed, even when an error is returned (for
     * instance if a database integrity error happened).
     *
     * @generated from field: vtrpc.RPCError error = 1;
     */
    error?: RPCError;
    /**
     * session is the updated session information.
     *
     * @generated from field: vtgate.Session session = 2;
     */
    session?: Session;
    /**
     * fields contains the fields, only set if error is unset.
     *
     * @generated from field: repeated query.Field fields = 3;
     */
    fields: Field[];
    constructor(data?: PartialMessage<PrepareResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.PrepareResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PrepareResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PrepareResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PrepareResponse;
    static equals(a: PrepareResponse | PlainMessage<PrepareResponse> | undefined, b: PrepareResponse | PlainMessage<PrepareResponse> | undefined): boolean;
}
/**
 * CloseSessionRequest is the payload to CloseSession.
 *
 * @generated from message vtgate.CloseSessionRequest
 */
export declare class CloseSessionRequest extends Message<CloseSessionRequest> {
    /**
     * caller_id identifies the caller. This is the effective caller ID,
     * set by the application to further identify the caller.
     *
     * @generated from field: vtrpc.CallerID caller_id = 1;
     */
    callerId?: CallerID;
    /**
     * session carries the session state.
     *
     * @generated from field: vtgate.Session session = 2;
     */
    session?: Session;
    constructor(data?: PartialMessage<CloseSessionRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.CloseSessionRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CloseSessionRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CloseSessionRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CloseSessionRequest;
    static equals(a: CloseSessionRequest | PlainMessage<CloseSessionRequest> | undefined, b: CloseSessionRequest | PlainMessage<CloseSessionRequest> | undefined): boolean;
}
/**
 * CloseSessionResponse is the returned value from CloseSession.
 *
 * @generated from message vtgate.CloseSessionResponse
 */
export declare class CloseSessionResponse extends Message<CloseSessionResponse> {
    /**
     * error contains an application level error if necessary. Note the
     * session may have changed, even when an error is returned (for
     * instance if a database integrity error happened).
     *
     * @generated from field: vtrpc.RPCError error = 1;
     */
    error?: RPCError;
    constructor(data?: PartialMessage<CloseSessionResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "vtgate.CloseSessionResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CloseSessionResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CloseSessionResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CloseSessionResponse;
    static equals(a: CloseSessionResponse | PlainMessage<CloseSessionResponse> | undefined, b: CloseSessionResponse | PlainMessage<CloseSessionResponse> | undefined): boolean;
}