@geodedb/client 1.0.2 → 1.3.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import * as tls from 'node:tls';
+import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
 import { Decimal } from 'decimal.js-light';
 export { default as Decimal } from 'decimal.js-light';
 
@@ -73,12 +74,32 @@ interface GeodeConfig {
     keepAliveInterval?: number;
     /** Maximum idle time in milliseconds (default: 30000) */
     maxIdleTime?: number;
-    /** Inline receive timeout in milliseconds (default: 5000) */
+    /**
+     * How long to wait for the data page the server sends inline after SCHEMA
+     * before falling back to an explicit PULL, in milliseconds (default: 5000).
+     * DSN key: `inline_timeout`.
+     *
+     * The inline response is never discarded when this deadline passes: the
+     * client keeps track of it and reconciles it with the PULL answer, so a slow
+     * first page can never leak into the next query (ENG-3916). Lower it only to
+     * make the client fall back to PULL sooner; `requestTimeout` still bounds
+     * the whole exchange.
+     */
     inlineTimeout?: number;
     /** Enable TLS for gRPC (default: true) */
     tls?: boolean;
     /** Graph name for DSN graph binding. When set, the server binds the session to this graph. */
     graph?: string;
+    /**
+     * Tenant identifier sent in the HELLO handshake (proto field 3). Required for
+     * multi-tenant deployments so the server scopes the session to this tenant.
+     */
+    tenant?: string;
+    /**
+     * FLE role sent in the HELLO handshake (proto field 8). Selects the
+     * field-level-encryption role for the session when set.
+     */
+    role?: string;
 }
 /**
  * Connection pool configuration.
@@ -122,6 +143,9 @@ declare function defaultConfig(): GeodeConfig;
  *   - server_name: SNI server name
  *   - connect_timeout: Connection timeout in ms
  *   - request_timeout: Request timeout in ms
+ *   - graph: Graph to bind the session to
+ *   - tenant/tenant_id: Tenant identifier for multi-tenant deployments
+ *   - role: FLE role for field-level access control
  *
  * Environment variables (used as defaults):
  *   - GEODE_HOST: Default host
@@ -129,6 +153,8 @@ declare function defaultConfig(): GeodeConfig;
  *   - GEODE_TLS_CA: Default CA certificate path
  *   - GEODE_USERNAME: Default username
  *   - GEODE_PASSWORD: Default password
+ *   - GEODE_TENANT: Default tenant identifier
+ *   - GEODE_ROLE: Default FLE role
  *   - GEODE_TRANSPORT: Default transport type (quic or grpc)
  */
 declare function parseDSN(dsn: string): GeodeConfig;
@@ -140,6 +166,13 @@ declare function validateConfig(cfg: GeodeConfig): void;
  * Get the server address in host:port format.
  */
 declare function getAddress(cfg: GeodeConfig): string;
+/**
+ * Serialise a GeodeConfig back to a DSN string. Inverse of parseDSN: only
+ * non-default values are emitted as query parameters to keep the DSN minimal.
+ * Credentials go in the userinfo segment when both username and password are
+ * present; a lone username uses userinfo, a lone password uses a `pass` param.
+ */
+declare function formatDSN(cfg: GeodeConfig): string;
 /**
  * Clone configuration.
  */
@@ -275,6 +308,8 @@ declare class StateError extends Error implements GeodeError {
  * Connection state enumeration.
  */
 type ConnectionState = 'idle' | 'executing' | 'in_transaction' | 'fetching' | 'closed' | 'error';
+declare const ERR_INVALID_IDENT_MESSAGE = "geode: identifier contains forbidden characters";
+declare const ERR_INVALID_STRING_MESSAGE = "geode: string literal contains forbidden characters";
 declare const ERR_CLOSED_MESSAGE = "geode: connection closed";
 declare const ERR_QUERY_IN_PROGRESS_MESSAGE = "geode: query already in progress";
 declare const ERR_TX_IN_PROGRESS_MESSAGE = "geode: transaction already in progress";
@@ -282,13 +317,23 @@ declare const ERR_NO_TX_MESSAGE = "geode: no transaction in progress";
 declare const ERR_TX_DONE_MESSAGE = "geode: transaction already committed or rolled back";
 declare const ERR_ROWS_CLOSED_MESSAGE = "geode: rows closed";
 declare const ERR_BAD_CONN_MESSAGE = "geode: bad connection";
+declare const ERR_NO_ROWS_MESSAGE = "geode: no rows in result set";
+declare function ErrInvalidIdent(): Error;
+declare function ErrInvalidString(): Error;
 declare function ErrClosed(): Error;
+/**
+ * @deprecated No longer thrown by `Connection`. Concurrent requests on one
+ * connection are serialized on the connection's exchange lock instead of
+ * failing fast (ENG-3916). Kept exported so existing identity checks still
+ * compile.
+ */
 declare function ErrQueryInProgress(): Error;
 declare function ErrTxInProgress(): Error;
 declare function ErrNoTx(): Error;
 declare function ErrTxDone(): Error;
 declare function ErrRowsClosed(): Error;
 declare function ErrBadConn(): Error;
+declare function ErrNoRows(): Error;
 /**
  * Check if an error is a specific sentinel error by message.
  */
@@ -305,282 +350,666 @@ declare function isGeodeError(err: unknown): err is GeodeError;
  * Check if an error is retryable.
  */
 declare function isRetryableError(err: unknown): boolean;
-
 /**
- * Geode Protobuf Wire Protocol
- *
- * Uses protobufjs for encoding/decoding protocol messages.
- * Wire format for QUIC: 4-byte Big Endian length prefix + protobuf message body.
+ * Reports whether `err` is a Geode authentication/authorization failure
+ * (GQL status class 28000 or the Geode-specific 08P01 password-reset
+ * extension). Returns false for null and for non-driver errors.
+ */
+declare function isAuthError(err: unknown): boolean;
+/**
+ * Reports whether `err` is a GQL parse/syntax error (status class 42000).
+ * Returns false for null and for non-driver errors.
+ */
+declare function isSyntaxError(err: unknown): boolean;
+
+declare enum IntKind {
+    INT_KIND_UNSPECIFIED = 0,
+    INT = 1,
+    SMALLINT = 2,
+    BIGINT = 3
+}
+declare enum FloatKind {
+    FLOAT_KIND_UNSPECIFIED = 0,
+    DOUBLE = 1,
+    REAL = 2
+}
+declare enum StringKind {
+    STRING_KIND_UNSPECIFIED = 0,
+    STRING = 1,
+    CHAR = 2,
+    VARCHAR = 3,
+    TEXT = 4
+}
+declare enum BytesKind {
+    BYTES_KIND_UNSPECIFIED = 0,
+    BYTEA = 1,
+    RAW = 2
+}
+/**
+ * ============================================================================
+ * QUIC Messages
+ * ============================================================================
+ */
+interface QuicClientMessage {
+    hello?: HelloRequest | undefined;
+    execute?: ExecuteRequest | undefined;
+    pull?: PullRequest | undefined;
+    ping?: PingRequest | undefined;
+    cdcDiag?: CdcDiagnosticsRequest | undefined;
+    cdcCtrl?: CdcControlRequest | undefined;
+    begin?: BeginRequest | undefined;
+    commit?: CommitRequest | undefined;
+    rollback?: RollbackRequest | undefined;
+    savepoint?: SavepointRequest | undefined;
+    rollbackTo?: RollbackToRequest | undefined;
+    backup?: BackupRequest | undefined;
+    restore?: RestoreRequest | undefined;
+    uploadBackup?: UploadBackupRequest | undefined;
+}
+declare const QuicClientMessage: MessageFns<QuicClientMessage>;
+interface QuicServerMessage {
+    hello?: HelloResponse | undefined;
+    execute?: ExecutionResponse | undefined;
+    pull?: PullResponse | undefined;
+    ping?: PingResponse | undefined;
+    cdcDiag?: CdcDiagnosticsResponse | undefined;
+    cdcCtrl?: CdcControlResponse | undefined;
+    begin?: BeginResponse | undefined;
+    commit?: CommitResponse | undefined;
+    rollback?: RollbackResponse | undefined;
+    savepoint?: SavepointResponse | undefined;
+    rollbackTo?: RollbackToResponse | undefined;
+    backup?: BackupResponse | undefined;
+    restore?: RestoreResponse | undefined;
+    uploadBackup?: UploadBackupResponse | undefined;
+}
+declare const QuicServerMessage: MessageFns<QuicServerMessage>;
+/**
+ * ============================================================================
+ * Authentication (HELLO)
+ * ============================================================================
  */
 interface HelloRequest {
     username: string;
     password: string;
-    tenantId?: string;
+    tenantId?: string | undefined;
     clientName: string;
     clientVersion: string;
     wantedConformance: string;
-    graph?: string;
+    graph?: string | undefined;
+    /** FLE role for field-level access control */
+    role?: string | undefined;
 }
+declare const HelloRequest: MessageFns<HelloRequest>;
 interface HelloResponse {
     success: boolean;
     sessionId: string;
     errorMessage: string;
     capabilities: string[];
-    passwordResetRequired?: boolean;
-    graph?: string;
-}
-interface Param {
-    name: string;
-    value: ProtoValue;
+    passwordResetRequired: boolean;
+    graph?: string | undefined;
 }
+declare const HelloResponse: MessageFns<HelloResponse>;
+/**
+ * ============================================================================
+ * Query Execution (RUN_GQL + PULL)
+ * ============================================================================
+ */
 interface ExecuteRequest {
     sessionId: string;
     query: string;
     params: Param[];
 }
+declare const ExecuteRequest: MessageFns<ExecuteRequest>;
+interface Param {
+    name: string;
+    value?: Value | undefined;
+}
+declare const Param: MessageFns<Param>;
 interface PullRequest {
-    requestId: bigint | number;
+    requestId: bigint;
     pageSize: number;
+    /** Required for gRPC; ignored for QUIC */
     sessionId: string;
 }
+declare const PullRequest: MessageFns<PullRequest>;
 interface PullResponse {
-    response?: ExecutionResponse;
+    response?: ExecutionResponse | undefined;
 }
+declare const PullResponse: MessageFns<PullResponse>;
+/**
+ * ============================================================================
+ * Execution Responses
+ * ============================================================================
+ */
 interface Status {
+    /** e.g., "00000" */
     statusClass: string;
     statusSubclass: string;
     additionalStatuses: string[];
     flaggerFindings: string[];
 }
+declare const Status: MessageFns<Status>;
+interface ExecutionResponse {
+    status?: Status | undefined;
+    schema?: SchemaDefinition | undefined;
+    page?: DataPage | undefined;
+    error?: Error$1 | undefined;
+    metrics?: ExecutionMetrics | undefined;
+    explain?: ExplainPayload | undefined;
+    profile?: ProfilePayload | undefined;
+    heartbeat?: Heartbeat | undefined;
+}
+declare const ExecutionResponse: MessageFns<ExecutionResponse>;
+interface SchemaDefinition {
+    columns: ColumnDefinition[];
+}
+declare const SchemaDefinition: MessageFns<SchemaDefinition>;
 interface ColumnDefinition {
     name: string;
     type: string;
 }
-interface SchemaDefinition {
-    columns: ColumnDefinition[];
-}
-interface ProtoValue {
-    nullVal?: NullValue;
-    intVal?: IntValue;
-    doubleVal?: DoubleValue;
-    boolVal?: boolean;
-    stringVal?: StringValue;
-    decimalVal?: DecimalValue;
-    bytesVal?: BytesValue;
-    listVal?: ListValue;
-    mapVal?: MapValue;
-    nodeVal?: NodeValue;
-    edgeVal?: EdgeValue;
-    pathVal?: PathValue;
-    extVal?: ExtendedValue;
+declare const ColumnDefinition: MessageFns<ColumnDefinition>;
+interface DataPage {
+    rows: Row$1[];
+    final: boolean;
+    ordered: boolean;
+    orderKeys: string[];
 }
+declare const DataPage: MessageFns<DataPage>;
+interface Row$1 {
+    values: Value[];
+}
+declare const Row$1: MessageFns<Row$1>;
+/**
+ * ----------------------------------------------------------------------------
+ * Value Encoding
+ * ----------------------------------------------------------------------------
+ */
+interface Value {
+    nullVal?: NullValue | undefined;
+    intVal?: IntValue | undefined;
+    doubleVal?: DoubleValue | undefined;
+    boolVal?: boolean | undefined;
+    stringVal?: StringValue | undefined;
+    decimalVal?: DecimalValue | undefined;
+    bytesVal?: BytesValue | undefined;
+    listVal?: ListValue | undefined;
+    mapVal?: MapValue | undefined;
+    nodeVal?: NodeValue | undefined;
+    edgeVal?: EdgeValue | undefined;
+    pathVal?: PathValue | undefined;
+    extVal?: ExtendedValue | undefined;
+}
+declare const Value: MessageFns<Value>;
 interface NullValue {
 }
+declare const NullValue: MessageFns<NullValue>;
 interface IntValue {
-    value: bigint | number;
-    kind: number;
+    value: bigint;
+    kind: IntKind;
 }
+declare const IntValue: MessageFns<IntValue>;
 interface DoubleValue {
     value: number;
-    kind: number;
+    kind: FloatKind;
 }
+declare const DoubleValue: MessageFns<DoubleValue>;
 interface StringValue {
     value: string;
-    kind: number;
+    kind: StringKind;
 }
+declare const StringValue: MessageFns<StringValue>;
 interface DecimalValue {
+    /** i128 as decimal string */
     coeff: string;
     scale: number;
     origScale: number;
     origRepr: string;
 }
+declare const DecimalValue: MessageFns<DecimalValue>;
 interface BytesValue {
     value: Uint8Array;
-    kind: number;
+    kind: BytesKind;
 }
+declare const BytesValue: MessageFns<BytesValue>;
 interface ListValue {
-    values: ProtoValue[];
+    values: Value[];
 }
+declare const ListValue: MessageFns<ListValue>;
 interface MapEntry {
     key: string;
-    value: ProtoValue;
+    value?: Value | undefined;
 }
+declare const MapEntry: MessageFns<MapEntry>;
 interface MapValue {
     entries: MapEntry[];
 }
+declare const MapValue: MessageFns<MapValue>;
 interface NodeValue {
-    id: bigint | number;
+    id: bigint;
     labels: string[];
     properties: MapEntry[];
 }
+declare const NodeValue: MessageFns<NodeValue>;
 interface EdgeValue {
-    id: bigint | number;
-    fromId: bigint | number;
-    toId: bigint | number;
+    id: bigint;
+    fromId: bigint;
+    toId: bigint;
     label: string;
     properties: MapEntry[];
 }
+declare const EdgeValue: MessageFns<EdgeValue>;
 interface PathValue {
     nodes: NodeValue[];
     edges: EdgeValue[];
 }
+declare const PathValue: MessageFns<PathValue>;
 interface ExtendedValue {
     typeName: string;
-    text?: string;
-    bytes?: Uint8Array;
-    intVal?: bigint | number;
-    doubleVal?: number;
-    boolVal?: boolean;
-}
-interface Row$1 {
-    values: ProtoValue[];
-}
-interface DataPage {
-    rows: Row$1[];
-    final: boolean;
-    ordered: boolean;
-    orderKeys: string[];
-}
-interface ProtoError {
+    text?: string | undefined;
+    bytes?: Uint8Array | undefined;
+    intVal?: bigint | undefined;
+    doubleVal?: number | undefined;
+    boolVal?: boolean | undefined;
+}
+declare const ExtendedValue: MessageFns<ExtendedValue>;
+interface Error$1 {
     code: string;
     message: string;
+    /** "ERROR" */
     type: string;
     anchor: string;
 }
+declare const Error$1: MessageFns<Error$1>;
 interface ExecutionMetrics {
-    parseDurationNs: bigint | number;
-    planDurationNs: bigint | number;
-    executeDurationNs: bigint | number;
-    totalDurationNs: bigint | number;
-}
+    parseDurationNs: bigint;
+    planDurationNs: bigint;
+    executeDurationNs: bigint;
+    totalDurationNs: bigint;
+}
+declare const ExecutionMetrics: MessageFns<ExecutionMetrics>;
+interface ExplainOp {
+    idx: number;
+    kind: string;
+    estRows: bigint;
+    cost: bigint;
+}
+declare const ExplainOp: MessageFns<ExplainOp>;
 interface ExplainTotals {
-    cost?: number;
-    est_rows?: number;
+    estRows: bigint;
+    cost: bigint;
 }
+declare const ExplainTotals: MessageFns<ExplainTotals>;
+interface ExplainProperties {
+    ordered: boolean;
+    limit: bigint;
+    offset: bigint;
+    distinct: boolean;
+    unionMode: string;
+    unionPartCount: number;
+}
+declare const ExplainProperties: MessageFns<ExplainProperties>;
+interface ExplainCalibrationEntry {
+    idx: number;
+    estRows: number;
+    actualRows: number;
+}
+declare const ExplainCalibrationEntry: MessageFns<ExplainCalibrationEntry>;
+interface ExplainCalibration {
+    mape: number;
+    entries: ExplainCalibrationEntry[];
+}
+declare const ExplainCalibration: MessageFns<ExplainCalibration>;
 interface ExplainPayload {
     schema: string;
-    ops: unknown[];
-    totals?: ExplainTotals;
-    properties: unknown;
-    calibration: unknown;
+    ops: ExplainOp[];
+    totals?: ExplainTotals | undefined;
+    properties?: ExplainProperties | undefined;
+    calibration?: ExplainCalibration | undefined;
     profileVersion: number;
 }
+declare const ExplainPayload: MessageFns<ExplainPayload>;
+interface ProfileOp {
+    op: string;
+    phase: string;
+    id: number;
+    opIndex: number;
+    inputRows: bigint;
+    rows: bigint;
+    timeNs: bigint;
+    cpuTimeNs: bigint;
+    bytesOut: bigint;
+    bytesAlloc: bigint;
+    estimateBytes: bigint;
+    estimateVsActual: bigint;
+    percentPeak: bigint;
+    percentNet: bigint;
+    cumulativeTimeNs: bigint;
+    freedBytes: bigint;
+    netAfterOp: bigint;
+    errorBytes: bigint;
+    errorAbsPct: bigint;
+    indexName: string;
+    selectivityEst: number;
+}
+declare const ProfileOp: MessageFns<ProfileOp>;
+interface ProfilePeakContributor {
+    op: string;
+    bytesAlloc: bigint;
+}
+declare const ProfilePeakContributor: MessageFns<ProfilePeakContributor>;
+interface ProfileTotals {
+    timeNs: bigint;
+    peakBytes: bigint;
+}
+declare const ProfileTotals: MessageFns<ProfileTotals>;
+interface ProfileSpills {
+    sortSpills: bigint;
+    distinctSpills: bigint;
+    unionSpills: bigint;
+    spillReason: string;
+    peakBytesAtSpill: bigint;
+    firstSpillOpIndex: number;
+}
+declare const ProfileSpills: MessageFns<ProfileSpills>;
 interface ProfileMemory {
-    netBytes?: number | bigint;
-    peakBytes?: number | bigint;
-    totalAllocBytes?: number | bigint;
+    netBytes: bigint;
+    peakBytes: bigint;
+    totalAllocBytes: bigint;
+}
+declare const ProfileMemory: MessageFns<ProfileMemory>;
+interface ProfilePlannerEstimates {
+    sumEstimateBytes: bigint;
+    sumActualBytes: bigint;
+    countEstimatedOps: number;
+    minErrorAbsPct: number;
+    maxErrorAbsPct: number;
+    meanErrorAbsPct: number;
+    medianErrorAbsPct: number;
+    stddevErrorAbsPct: number;
+    adjustedEstimateFactor: number;
+}
+declare const ProfilePlannerEstimates: MessageFns<ProfilePlannerEstimates>;
+interface ProfileMemCurvePoint {
+    opIndex: number;
+    netAfterOp: bigint;
+}
+declare const ProfileMemCurvePoint: MessageFns<ProfileMemCurvePoint>;
+interface ProfileSetOp {
+    type: string;
+    mode: string;
+    inputRows: bigint;
+    outputRows: bigint;
+    hashDedupSize: bigint;
+    distinctFillPct: bigint;
 }
+declare const ProfileSetOp: MessageFns<ProfileSetOp>;
 interface ProfilePayload {
     profileVersion: number;
-    ops: unknown[];
-    peakContributors: unknown[];
-    totals: unknown;
-    totalTimeNs: bigint | number;
-    spills: unknown;
-    memory?: ProfileMemory;
-    plannerEstimates: unknown;
-    memCurve: unknown[];
-    setop: unknown;
-    hashaggSpills: bigint | number;
+    ops: ProfileOp[];
+    peakContributors: ProfilePeakContributor[];
+    totals?: ProfileTotals | undefined;
+    totalTimeNs: bigint;
+    spills?: ProfileSpills | undefined;
+    memory?: ProfileMemory | undefined;
+    plannerEstimates?: ProfilePlannerEstimates | undefined;
+    memCurve: ProfileMemCurvePoint[];
+    setop?: ProfileSetOp | undefined;
+    hashaggSpills: bigint;
     hashaggSpillReason: string;
-    committedTxns: bigint | number;
-    graphStoreNodes: bigint | number;
-    graphStoreEdges: bigint | number;
+    committedTxns: bigint;
+    graphStoreNodes: bigint;
+    graphStoreEdges: bigint;
     graphStoreDirty: boolean;
     flaggerFindings: string[];
     compact: boolean;
 }
+declare const ProfilePayload: MessageFns<ProfilePayload>;
 interface Heartbeat {
 }
-interface ExecutionResponse {
-    status?: Status;
-    schema?: SchemaDefinition;
-    page?: DataPage;
-    error?: ProtoError;
-    metrics?: ExecutionMetrics;
-    explain?: ExplainPayload;
-    profile?: ProfilePayload;
-    heartbeat?: Heartbeat;
-}
+declare const Heartbeat: MessageFns<Heartbeat>;
+/**
+ * ============================================================================
+ * Utilities (PING)
+ * ============================================================================
+ */
 interface PingRequest {
 }
+declare const PingRequest: MessageFns<PingRequest>;
 interface PingResponse {
     ok: boolean;
 }
+declare const PingResponse: MessageFns<PingResponse>;
+/**
+ * ============================================================================
+ * Transactions
+ * ============================================================================
+ */
 interface BeginRequest {
     readOnly: boolean;
+    /** Required for gRPC; ignored for QUIC */
     sessionId: string;
 }
+declare const BeginRequest: MessageFns<BeginRequest>;
 interface BeginResponse {
     sessionId: string;
     txId: string;
 }
+declare const BeginResponse: MessageFns<BeginResponse>;
 interface CommitRequest {
+    /** Required for gRPC; ignored for QUIC */
     sessionId: string;
 }
+declare const CommitRequest: MessageFns<CommitRequest>;
 interface CommitResponse {
     success: boolean;
 }
+declare const CommitResponse: MessageFns<CommitResponse>;
 interface RollbackRequest {
+    /** Required for gRPC; ignored for QUIC */
     sessionId: string;
 }
+declare const RollbackRequest: MessageFns<RollbackRequest>;
 interface RollbackResponse {
     success: boolean;
 }
+declare const RollbackResponse: MessageFns<RollbackResponse>;
 interface SavepointRequest {
     name: string;
+    /** Required for gRPC; ignored for QUIC */
     sessionId: string;
 }
+declare const SavepointRequest: MessageFns<SavepointRequest>;
 interface SavepointResponse {
     success: boolean;
 }
+declare const SavepointResponse: MessageFns<SavepointResponse>;
 interface RollbackToRequest {
     name: string;
+    /** Required for gRPC; ignored for QUIC */
     sessionId: string;
 }
+declare const RollbackToRequest: MessageFns<RollbackToRequest>;
 interface RollbackToResponse {
     success: boolean;
 }
-interface QuicClientMessage {
-    hello?: HelloRequest;
-    execute?: ExecuteRequest;
-    pull?: PullRequest;
-    ping?: PingRequest;
-    cdcDiag?: unknown;
-    cdcCtrl?: unknown;
-    begin?: BeginRequest;
-    commit?: CommitRequest;
-    rollback?: RollbackRequest;
-    savepoint?: SavepointRequest;
-    rollbackTo?: RollbackToRequest;
-    backup?: unknown;
-    restore?: unknown;
-    uploadBackup?: unknown;
+declare const RollbackToResponse: MessageFns<RollbackToResponse>;
+/**
+ * ============================================================================
+ * CDC
+ * ============================================================================
+ */
+interface CdcDiagnosticsRequest {
+    sessionId: string;
 }
-interface QuicServerMessage {
-    hello?: HelloResponse;
-    execute?: ExecutionResponse;
-    pull?: PullResponse;
-    ping?: PingResponse;
-    cdcDiag?: unknown;
-    cdcCtrl?: unknown;
-    begin?: BeginResponse;
-    commit?: CommitResponse;
-    rollback?: RollbackResponse;
-    savepoint?: SavepointResponse;
-    rollbackTo?: RollbackToResponse;
-    backup?: unknown;
-    restore?: unknown;
-    uploadBackup?: unknown;
+declare const CdcDiagnosticsRequest: MessageFns<CdcDiagnosticsRequest>;
+interface CdcDiagnosticsConfig {
+    enabled: boolean;
+    malformedSnapshotInterval: bigint;
+    malformedHashRetain: number;
+    malformedWarnPct: number;
+    malformedAbortPct: number;
+    flushIntervalMs: number;
+    batchSize: number;
+    pendingBackpressureWatermark: bigint;
+}
+declare const CdcDiagnosticsConfig: MessageFns<CdcDiagnosticsConfig>;
+interface CdcDiagnosticsEngine {
+    isRunning: boolean;
+    lastFlushMs: bigint;
+    peakBuffer: bigint;
+    currentBuffer: bigint;
+    dynamicBatchSize: number;
+    batchAdjustments: number;
+}
+declare const CdcDiagnosticsEngine: MessageFns<CdcDiagnosticsEngine>;
+interface CdcMalformedSnapshot {
+    count: bigint;
+    tsMs: bigint;
+}
+declare const CdcMalformedSnapshot: MessageFns<CdcMalformedSnapshot>;
+interface CdcMalformedHash {
+    count: bigint;
+    hash: bigint;
+    tsMs: bigint;
+    prefixHex: string;
+}
+declare const CdcMalformedHash: MessageFns<CdcMalformedHash>;
+interface CdcDiagnosticsResponse {
+    malformedChangeRecords: bigint;
+    totalChangeAttempts: bigint;
+    malformedRatio: number;
+    guardrailWarnTriggered: boolean;
+    guardrailAbortTriggered: boolean;
+    firstWarnTsMs: bigint;
+    firstAbortTsMs: bigint;
+    guardrailEpoch: bigint;
+    uptimeMs: bigint;
+    backpressure: boolean;
+    config?: CdcDiagnosticsConfig | undefined;
+    engine?: CdcDiagnosticsEngine | undefined;
+    malformedSnapshots: CdcMalformedSnapshot[];
+    malformedHashes: CdcMalformedHash[];
+    version: string;
+    timestampMs: bigint;
+}
+declare const CdcDiagnosticsResponse: MessageFns<CdcDiagnosticsResponse>;
+interface CdcControlRequest {
+    action: string;
+    sessionId: string;
+}
+declare const CdcControlRequest: MessageFns<CdcControlRequest>;
+interface CdcControlResponse {
+    success: boolean;
+    status: string;
+    guardrailEpoch: bigint;
+}
+declare const CdcControlResponse: MessageFns<CdcControlResponse>;
+/**
+ * ============================================================================
+ * Backup / Restore
+ * ============================================================================
+ */
+interface BackupRequest {
+    /** "full" */
+    backupType: string;
+    sessionId: string;
+    compress: boolean;
+}
+declare const BackupRequest: MessageFns<BackupRequest>;
+interface BackupResponse {
+    success: boolean;
+    message: string;
+    backupId: string;
+    backupType: string;
+    sizeBytes: bigint;
+    compression: string;
+    checksum: string;
+}
+declare const BackupResponse: MessageFns<BackupResponse>;
+interface RestoreRequest {
+    targetTime: string;
+    confirm: boolean;
+    sessionId: string;
 }
+declare const RestoreRequest: MessageFns<RestoreRequest>;
+interface RestoreResponse {
+    success: boolean;
+    message: string;
+    restoreDir: string;
+    targetTime: string;
+    restoreTimestamp: bigint;
+}
+declare const RestoreResponse: MessageFns<RestoreResponse>;
+interface UploadBackupRequest {
+    sizeBytes: bigint;
+    checksum: string;
+    sessionId: string;
+    /**
+     * GAP-0880: full backup artifact bytes (GEOB header + payload). Required;
+     * metadata-only uploads are rejected by the server.
+     */
+    payload: Uint8Array;
+}
+declare const UploadBackupRequest: MessageFns<UploadBackupRequest>;
+interface UploadBackupResponse {
+    success: boolean;
+    message: string;
+    uploadPath: string;
+}
+declare const UploadBackupResponse: MessageFns<UploadBackupResponse>;
+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 {} ? {
+    [K in keyof T]?: 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>>]: never;
+};
+interface MessageFns<T> {
+    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;
+}
+
+/**
+ * Geode Protobuf Wire Protocol
+ *
+ * Encoding/decoding of protocol messages using the protoc + ts-proto generated
+ * bindings (src/generated/geode.ts), which are produced from the canonical
+ * geode server proto. This eliminates proto drift: there are no longer any
+ * hand-written message interfaces, and the proto is no longer parsed at runtime
+ * via protobufjs.
+ *
+ * Wire format for QUIC: 4-byte Big Endian length prefix + protobuf message body.
+ *
+ * The public API (the build/encode/decode/value-conversion helpers and the
+ * exported types) is preserved exactly. Legacy type names that differ from the
+ * proto message names are aliased: the proto `Value` message is exported as
+ * `ProtoValue`, and the proto `Error` message as `ProtoError`.
+ */
+
+/** A protobuf `Value` message (alias preserved for API stability). */
+type ProtoValue = Value;
+/** A protobuf `Error` message (alias preserved for API stability). */
+type ProtoError = Error$1;
 /**
  * Initialize protobuf types synchronously.
- * Safe to call multiple times; only loads on first call.
- * Prefer ensureProtoInitialized() in async contexts to avoid blocking the event loop.
+ *
+ * No-op: bindings are generated at build time (protoc + ts-proto) and statically
+ * imported, so no runtime initialization is required. Retained for API stability.
  */
 declare function initProtoSync(): void;
 /**
  * Ensure proto is initialized.
+ *
+ * No-op: see {@link initProtoSync}. Retained for API stability.
  */
 declare function ensureProtoInitialized(): Promise<void>;
 /**
@@ -610,7 +1039,7 @@ declare function decodeLengthPrefix(data: Buffer): number;
 /**
  * Build a HelloRequest message.
  */
-declare function buildHelloRequest(username: string, password: string, clientName: string, clientVersion: string, conformance: string, tenantId?: string, graph?: string): QuicClientMessage;
+declare function buildHelloRequest(username: string, password: string, clientName: string, clientVersion: string, conformance: string, tenantId?: string, graph?: string, role?: string): QuicClientMessage;
 /**
  * Build an ExecuteRequest message.
  */
@@ -618,7 +1047,7 @@ declare function buildExecuteRequest(sessionId: string, query: string, params?:
 /**
  * Build a PullRequest message.
  */
-declare function buildPullRequest(requestId: number, pageSize: number, sessionId: string): QuicClientMessage;
+declare function buildPullRequest(requestId: number | bigint, pageSize: number, sessionId: string): QuicClientMessage;
 /**
  * Build a PingRequest message.
  */
@@ -709,6 +1138,25 @@ declare class QuicTransport extends BaseTransport {
     private _maxBufferBytes;
     private _pendingProtoReads;
     private _pendingResponses;
+    /**
+     * Decode failure that arrived while no reader was parked. Surfaced by the
+     * next receiveProto() once the already-decoded backlog has been drained.
+     */
+    private _pendingDecodeError;
+    /**
+     * Sticky failure latched when the read pump ends or throws. The pump is the
+     * ONLY producer of responses, so once it is gone nothing can ever settle a
+     * parked reader: report the failure instead of hanging (ENG-3918).
+     */
+    private _readFailure;
+    /** True once close() has released the QUIC client and buffers. */
+    private _disposed;
+    /**
+     * Serializes writes to the single bidirectional stream. `getWriter()` throws
+     * "WritableStream is locked" while another write holds the lock, so queued
+     * exchanges must take turns (ENG-3916).
+     */
+    private _writeChain;
     constructor(address: string, maxMessageSize?: number, maxBufferBytes?: number);
     /**
      * Connect to the Geode server using QUIC.
@@ -718,6 +1166,15 @@ declare class QuicTransport extends BaseTransport {
      * Start reading from the stream in the background.
      */
     private startReading;
+    /**
+     * Latch the transport dead after the read pump ends or throws.
+     *
+     * Nothing can produce a response once the pump is gone, so leaving
+     * `isClosed()` false makes the connection (and the pool, whose only liveness
+     * predicate is that flag) believe a dead socket is healthy, and parks every
+     * later reader on a producer that will never run again (ENG-3918).
+     */
+    private failFromReadPump;
     /**
      * Reject all pending reads with an error.
      */
@@ -998,6 +1455,10 @@ declare class QueryResult implements AsyncIterable<Row> {
     private _closed;
     private _bufferIndex;
     private _rowCount;
+    /** Settles once the connection is back in phase after this result closed. */
+    private _drained;
+    /** Owner hook (used by the pool to hold its member for the result's life). */
+    private _onCloseHooks;
     constructor(conn: Connection, columns: ColumnInfo[], initialRows: Record<string, unknown>[], final: boolean, ordered: boolean, orderKeys: string[], pageSize: number, signal?: AbortSignal);
     /**
      * Get column definitions.
@@ -1070,8 +1531,27 @@ declare class QueryResult implements AsyncIterable<Row> {
     reduce<T>(fn: (acc: T, row: Row, index: number) => T | Promise<T>, initial: T): Promise<T>;
     /**
      * Close the result set.
+     *
+     * When the server still owes pages, closing hands the connection the job of
+     * draining them; use {@link QueryResult._settle} (or simply iterate to the
+     * end) to await that. A caller that walks away never observes a connection
+     * that is silently out of phase (ENG-3916).
      */
     close(): void;
+    /**
+     * @internal Whether the result still needs the connection.
+     *
+     * False once every page is buffered client-side: the connection is then free
+     * and its pool member can be released immediately.
+     */
+    get _needsConnection(): boolean;
+    /**
+     * @internal Register a callback fired exactly once when this result closes.
+     * Fires immediately when the result is already closed.
+     */
+    _onClose(hook: () => void): void;
+    /** Close the result and wait for the connection to be back in phase. */
+    private _settle;
     /**
      * Internal close (called by connection).
      */
@@ -1556,11 +2036,11 @@ declare function batchMap(conn: Connection, queryTemplate: string, items: QueryP
  * Unlike the sequential batch(), this executes multiple queries concurrently
  * up to the specified limit.
  *
- * **Important:** A single `Connection` can only execute one query at a time
- * (the connection state machine throws `ErrQueryInProgress` for concurrent
- * queries). When a single connection is provided with concurrency > 1, this
- * function automatically falls back to sequential execution (concurrency=1)
- * to prevent runtime errors.
+ * **Important:** A single `Connection` owns one bidirectional stream and can
+ * only execute one query at a time; concurrent requests queue on its exchange
+ * lock rather than overlapping (ENG-3916). When a single connection is
+ * provided with concurrency > 1, this function falls back to sequential
+ * execution (concurrency=1) because the extra concurrency buys nothing.
  *
  * For true parallel execution, use a connection pool or connection factory
  * that provides separate connections per concurrent query.
@@ -1610,6 +2090,21 @@ declare class Connection {
     private _requestId;
     private _sessionId;
     private _columns;
+    private _delivery;
+    /**
+     * FIFO exchange lock.
+     *
+     * The connection owns ONE bidirectional stream and the wire protocol carries
+     * no request/response correlation id, so two overlapping exchanges would read
+     * each other's answers. Callers therefore queue instead of racing: an
+     * exchange holds the lock for its FULL request -> final-response round trip,
+     * and a streaming QueryResult keeps holding it until it is closed or drained
+     * (ENG-3916).
+     */
+    private _exchangeHeld;
+    private _exchangeWaiters;
+    /** Lock release handed to the active streaming result, if any. */
+    private _activeRelease;
     private constructor();
     /**
      * Create a new connection to the Geode server.
@@ -1629,12 +2124,27 @@ declare class Connection {
     get isClosed(): boolean;
     /** Get session ID. */
     get sessionId(): string;
+    /**
+     * Take the exchange lock, returning its (idempotent) release function.
+     *
+     * Registration is synchronous, so waiters are served strictly in call order.
+     */
+    private acquireExchange;
+    /** Run one complete exchange under the connection's exchange lock. */
+    private withExchange;
+    /** Wake every queued exchange so it can observe the closed state. */
+    private drainExchangeWaiters;
     /** Perform the HELLO handshake. */
     private hello;
     /** Execute a query that returns rows. */
     query(query: string, options?: QueryOptions): Promise<QueryResult>;
     /** Execute a query and return all rows as an array. */
     queryAll(query: string, options?: QueryOptions): Promise<Record<string, unknown>[]>;
+    /**
+     * Execute a query and return exactly the first row. Throws ErrNoRows when
+     * the result set is empty, mirroring database/sql's ErrNoRows.
+     */
+    queryRow(query: string, options?: QueryOptions): Promise<Record<string, unknown>>;
     /** Execute a query that doesn't return rows. */
     exec(query: string, options?: QueryOptions): Promise<void>;
     /** @internal Fetch the next page of results. Called by QueryResult. */
@@ -1642,20 +2152,78 @@ declare class Connection {
         rows: Record<string, unknown>[];
         final: boolean;
     }>;
-    /** Try to receive an inline response with short timeout. */
+    /**
+     * Read the next page off the stream.
+     *
+     * Accepts either envelope: the server pushes pages as `execute` responses and
+     * wraps a PULL's answer in `pull`. Anything else means the stream is out of
+     * phase with the request being served, so the connection fails closed instead
+     * of silently swallowing the message.
+     */
+    private _readNextPage;
+    /**
+     * Wait for the response the server sends after SCHEMA.
+     *
+     * Returns `null` when the inline deadline (`inlineTimeout`) expires. That
+     * response is then STILL in flight - the caller must reconcile it before
+     * returning, because the transport is a FIFO stream without request/response
+     * correlation and anything left behind is read by the next request
+     * (ENG-3916).
+     */
     private _tryReceiveInline;
-    /** Read inline execute responses until a page, error, heartbeat, or timeout arrives. */
+    /** Read inline execute responses until a page, error, heartbeat, or the inline deadline. */
     private _readInlineExecute;
-    /** Drain remaining data pages until final=true to prevent query corruption (QUAL-T7). */
+    /**
+     * Send a PULL and consume responses until every outstanding response has
+     * been accounted for.
+     *
+     * The wire protocol is a FIFO stream with no request/response correlation
+     * id, so the client must reconcile the whole exchange before it returns:
+     * a response left in the transport is read by the NEXT request, which then
+     * sees this query's schema and rows (ENG-3916). Up to two responses can be
+     * outstanding here:
+     *
+     *  - the inline page the server sends after SCHEMA, when the inline read
+     *    gave up waiting for it (`inlinePending`), and
+     *  - the answer to the PULL sent below, which QUIC servers always send as a
+     *    `pull`-wrapped message.
+     *
+     * Because the server writes its responses in order, a `pull`-wrapped answer
+     * also proves that nothing is still coming for the EXECUTE, which is what
+     * makes the reconciliation exact.
+     *
+     * When the exchange cannot be reconciled - a timeout, an abort or a
+     * transport failure while a response is still owed - the connection is
+     * closed instead of returned to the caller (and to the pool).
+     *
+     * NOTE (server team, ENG-3916): the durable fix is a request/response
+     * correlation id in the proto. Until the wire protocol carries one, the
+     * client can only reconcile by message type plus stream ordering.
+     */
+    private _pullFirstPage;
+    /**
+     * Drain remaining data pages until final=true to prevent query corruption
+     * (QUAL-T7). Honours the current delivery mode: pushed pages are read,
+     * parked results are pulled one page at a time.
+     */
     private _drainRemainingPages;
-    /** @internal Release the active result, returning the connection to idle. */
-    _releaseResult(result: QueryResult): void;
+    /**
+     * @internal Release the active result, returning the connection to idle.
+     *
+     * A result abandoned before `final = true` leaves pages the server still owes
+     * on the stream. They are drained here - under the exchange lock the result
+     * still holds - so the next caller cannot read them as its own (ENG-3916).
+     * The returned promise settles once the connection is back in phase.
+     */
+    _releaseResult(result: QueryResult, final: boolean): Promise<void>;
     /** Begin a transaction. */
     begin(signal?: AbortSignal): Promise<Transaction>;
     /** @internal Commit the current transaction. Called by Transaction. */
     _commit(signal?: AbortSignal): Promise<void>;
     /** @internal Rollback the current transaction. Called by Transaction. */
     _rollback(signal?: AbortSignal): Promise<void>;
+    /** Send ROLLBACK and consume its answer. The exchange lock must be held. */
+    private _rollbackExchange;
     /** @internal Create a named savepoint. Called by Transaction. */
     _savepoint(name: string, signal?: AbortSignal): Promise<void>;
     /** @internal Rollback to a previously created savepoint. Called by Transaction. */
@@ -1666,6 +2234,8 @@ declare class Connection {
     reset(signal?: AbortSignal): Promise<void>;
     /** Close the connection. */
     close(): Promise<void>;
+    /** Drop the active result and hand its exchange lock back. */
+    private _abandonActiveResult;
     /** Create a prepared statement. */
     prepare(query: string): Promise<PreparedStatement>;
     /** Get the query execution plan without executing. */
@@ -1674,7 +2244,12 @@ declare class Connection {
     profile(query: string, options?: ExplainOptions): Promise<QueryProfile>;
     /** Execute multiple queries in a batch. */
     batch(queries: BatchQuery[], options?: BatchOptions): Promise<BatchSummary>;
-    /** Check connection state before operation. */
+    /**
+     * Check connection state before operation.
+     *
+     * Concurrent requests are NOT rejected any more: they queue on the exchange
+     * lock (ENG-3916). Only genuinely illegal states fail fast here.
+     */
     private checkState;
     /** Send a protobuf message with request timeout enforcement. */
     private _sendWithTimeout;
@@ -1682,7 +2257,38 @@ declare class Connection {
     private _receiveWithTimeout;
     /** Create a combined abort signal from requestTimeout and optional caller signal (CWE-703). */
     private _withRequestTimeout;
+    /**
+     * Tear the connection down after a transport failure.
+     *
+     * `responseOwed` marks the cases where the server may still answer: a request
+     * deadline that elapsed, or any aborted receive. Those leave the stream out
+     * of phase, so the connection must not be reused (or returned to the pool)
+     * even though the underlying socket is still open (ENG-3918).
+     */
     private _closeOnTransportError;
+    /**
+     * Whether the server answers every PULL with its own message.
+     *
+     * QUIC servers reply to a PULL with a `pull`-wrapped response, so that
+     * response has to be consumed before the connection is back in phase. The
+     * gRPC transport has no PULL RPC: it serves PULLs from the Execute stream
+     * that is already open, so no extra message is produced.
+     */
+    private get _pullIsAcknowledged();
+    /**
+     * Tear the connection down after a protocol desync and build the error.
+     *
+     * The stream carries no correlation ids, so a message that cannot belong to
+     * the request being served means client and server are out of phase: every
+     * later response would answer an earlier request, silently handing one
+     * caller another caller's rows. Failing closed makes the connection
+     * unusable, and the pool drops closed connections instead of reusing them.
+     */
+    private _protocolDesync;
+    /** Close the transport and drop any active result, ignoring teardown errors. */
+    private _forceClose;
+    /** Return to the resting state, unless the connection was torn down. */
+    private _restoreIdleState;
 }
 
 /**
@@ -2262,12 +2868,22 @@ declare class ConnectionPool {
     withConnection<T>(fn: (conn: Connection) => Promise<T>, signal?: AbortSignal): Promise<T>;
     /**
      * Execute a query using a pooled connection.
+     *
+     * A streaming result keeps fetching pages from the connection it was created
+     * on, so the pooled member stays checked out until the result is closed
+     * (ENG-3916). A result whose rows are already buffered needs nothing further
+     * from the connection and releases the member right away.
      */
     query(query: string, options?: QueryOptions): Promise<QueryResult>;
     /**
      * Execute a query and return all rows.
      */
     queryAll(query: string, options?: QueryOptions): Promise<Record<string, unknown>[]>;
+    /**
+     * Execute a query using a pooled connection and return the first row.
+     * Throws ErrNoRows when the result set is empty.
+     */
+    queryRow(query: string, options?: QueryOptions): Promise<Record<string, unknown>>;
     /**
      * Execute a statement that doesn't return rows.
      */
@@ -2288,6 +2904,17 @@ declare class ConnectionPool {
      * Add a new connection to the pool with rate limiting and exponential backoff.
      */
     private addConnection;
+    /**
+     * Drop every idle member whose connection is no longer usable.
+     *
+     * `Connection.isClosed` is the pool's only liveness predicate, and a
+     * connection torn down after a desync reports closed: leaving those members
+     * in place both risks reuse and starves the pool of its maxConnections slots
+     * until the next maintenance tick (ENG-3918).
+     */
+    private evictBrokenConnections;
+    /** Close a discarded connection, ignoring teardown failures. */
+    private closeQuietly;
     /**
      * Remove a connection from the pool.
      */
@@ -2342,6 +2969,32 @@ declare function defaultRetryPolicy(): RetryPolicy;
  */
 declare function withRetry<T>(fn: () => Promise<T>, policy?: RetryPolicy): Promise<T>;
 
+/**
+ * GQL Quoting Helpers
+ *
+ * Ports geode-client-go quote.go: safe inlining of identifiers, string
+ * literals, and graph names into GQL admin statements.
+ */
+/**
+ * Return `name` stripped of any character that is not alphanumeric, underscore,
+ * or hyphen, so it can be inlined safely into a USE GRAPH statement.
+ */
+declare function sanitizeGraphName(name: string): string;
+/**
+ * Validate and return `name` in a form safe to inline into a GQL admin
+ * statement that takes an identifier. Valid identifiers consist of letters,
+ * digits, underscore, and hyphen, and must not start with a hyphen. Digits are
+ * permitted at any position. Throws ErrInvalidIdent for empty or invalid input.
+ */
+declare function quoteIdent(name: string): string;
+/**
+ * Return `s` wrapped in GQL single quotes with backslashes and single quotes
+ * escaped. ASCII control characters (< 0x20 or 0x7F) are rejected with
+ * ErrInvalidString. Escape order: backslash first (\ -> \\), then single
+ * quotes (' -> '').
+ */
+declare function quoteString(s: string): string;
+
 /**
  * gRPC Transport Layer
  *
@@ -2882,4 +3535,97 @@ declare function node(): NodePatternBuilder;
  */
 declare function edge(): EdgePatternBuilder;
 
-export { AuthClient, BaseTransport, type BatchOptions, type BatchQuery, type BatchResult, type BatchSummary, type BeginRequest, type BeginResponse, type ClientOptions, type ColumnDef, type ColumnDefinition, type ColumnInfo, type CommitRequest, type CommitResponse, ConfigError, Connection, ConnectionPool, type ConnectionState, type CreateRLSPolicyOptions, type CreateRoleOptions, type CreateUserOptions, DEFAULT_CONFORMANCE, DEFAULT_GRPC_PORT, DEFAULT_HELLO_NAME, DEFAULT_HELLO_VERSION, DEFAULT_PAGE_SIZE, DEFAULT_PORT, type DSNScheme, type DataPage, DriverError, ERR_BAD_CONN_MESSAGE, ERR_CLOSED_MESSAGE, ERR_NO_TX_MESSAGE, ERR_QUERY_IN_PROGRESS_MESSAGE, ERR_ROWS_CLOSED_MESSAGE, ERR_TX_DONE_MESSAGE, ERR_TX_IN_PROGRESS_MESSAGE, type EdgeDirection, type EdgePattern, EdgePatternBuilder, ErrBadConn, ErrClosed, ErrNoTx, ErrQueryInProgress, ErrRowsClosed, ErrTxDone, ErrTxInProgress, type ExecuteRequest, type ExecutionResponse, type ExplainOptions, type GQLEdge, type GQLId, type GQLNode, type GQLPath, type GQLRange, type GQLType, GQLValue, type GQLValueKind, GeodeClient, type GeodeConfig, type GeodeError, GrpcTransport, type HelloRequest, type HelloResponse, MAX_PAGE_SIZE, MAX_QUERY_LENGTH, MockTransport, type NodePattern, NodePatternBuilder, type OperationTiming, type Param, type ParameterInfo, PatternBuilder, type PatternElement, type Permission, type PingRequest, type PingResponse, type PlanOperation, type PoolConfig, PredicateBuilder, type PredicateOp, PreparedStatement, type ProtoError, type Row$1 as ProtoRow, type ProtoValue, type PullRequest, type PullResponse, QueryBuilder, type QueryOptions, type QueryParams, type QueryPlan, type QueryProfile, QueryResult, QueryResultIterator, type QuicClientMessage, type QuicServerMessage, QuicTransport, QuicTransport as QuicheTransport, type RLSPolicy, type RawEdge, type RetryPolicy, type Role, type RollbackRequest, type RollbackResponse, type Row, SUPPORTED_SCHEMES, type SchemaDefinition, SecurityError, type SortDirection, StateError, type Status, StatusClass, type StatusClassType, Transaction, type Transport, TransportError, type TransportType, type User, batch, batchAll, batchFirst, batchMap, batchParallel, buildBeginRequest, buildCommitRequest, buildExecuteRequest, buildHelloRequest, buildPingRequest, buildPullRequest, buildRollbackRequest, buildRollbackToRequest, buildSavepointRequest, buildTLSConfig, cloneConfig, createAuthClient, createClient, createClientWithConfig, createTransport, decodeLengthPrefix, decodeQuicServerMessage, defaultConfig, defaultRetryPolicy, edge, encodeQuicClientMessage, encodeWithLengthPrefix, ensureProtoInitialized, explain, extractParameters, formatPlan, formatProfile, fromJSON, getAddress, getProtoPath, initProtoSync, isDriverError, isGeodeError, isRetryableError, isSentinelError, jsToProtoValue, node, parseDSN, parseGQLType, parseRow, pattern, predicate, prepare, profile, protoValueToJS, query, redactConfig, redactDSN, rowToObject, rowToRecord, sanitizeForLog, validateConfig, validateHostname, validatePageSize, validateParamName, validateParamValue, validatePort, validateQuery, validateSavepointName, withRetry, withTransaction };
+/**
+ * Schema Loading
+ *
+ * Ports geode-client-go schema.go: read .gql files from a directory and turn
+ * them into Statements suitable for batchExec / pipelineExec.
+ */
+/** A GQL query paired with optional bound parameters. */
+interface Statement {
+    query: string;
+    params?: Record<string, unknown>;
+}
+/**
+ * Read all direct-child `.gql` files from `dir` and return Statements.
+ *
+ * Subdirectories are not traversed. Lines are split into statements at
+ * semicolons after stripping blank lines, line comments (`//` and `--`), and
+ * lines that do not start with a recognised GQL keyword.
+ */
+declare function parseSchemaFS(dir: string): Promise<Statement[]>;
+
+/**
+ * Pipeline / Batch Execution (GAP-0900)
+ *
+ * Ports geode-client-go batch.go PipelineExec/BatchExec:
+ *  - batchExec runs all statements inside one transaction, with retry.
+ *  - pipelineExec splits into chunks and runs up to maxWorkers concurrently;
+ *    the first error stops launching new chunks while in-flight chunks finish.
+ */
+
+/** Default number of statements per chunk in pipelineExec. */
+declare const DEFAULT_CHUNK_SIZE = 100;
+/** Default maximum number of concurrent chunk workers in pipelineExec. */
+declare const DEFAULT_MAX_WORKERS = 8;
+/** Minimal transaction surface pipelineExec needs. */
+interface PipelineTx {
+    exec(query: string, options?: {
+        params?: Record<string, unknown>;
+    }): Promise<void>;
+}
+/** Minimal pool surface pipelineExec needs (ConnectionPool satisfies this). */
+interface PipelineExecutor {
+    withTransaction<T>(fn: (tx: PipelineTx) => Promise<T>): Promise<T>;
+}
+/**
+ * Execute `stmts` inside a single transaction with automatic retry on
+ * retryable errors. An empty list is a no-op.
+ */
+declare function batchExec(pool: PipelineExecutor, stmts: Statement[]): Promise<void>;
+/**
+ * Execute `stmts` in parallel chunks. Splits into chunks of `chunkSize` and
+ * runs up to `maxWorkers` chunks concurrently; each chunk runs through
+ * batchExec. Returns the first error encountered; once an error occurs no new
+ * chunks are launched but in-flight chunks complete.
+ */
+declare function pipelineExec(pool: PipelineExecutor, stmts: Statement[], opts?: {
+    chunkSize?: number;
+    maxWorkers?: number;
+    signal?: AbortSignal;
+}): Promise<void>;
+
+/**
+ * Field-Level Encryption (FLE)
+ *
+ * Ports geode-client-go crypto/cipher.go using node:crypto:
+ *  - AES-256-GCM authenticated encryption (random 12-byte nonce, prepended).
+ *  - HKDF-SHA256 derives separate encryption and HMAC keys from a >= 32-byte
+ *    master key.
+ *  - HMAC-SHA256 hex digest for deterministic searchable encryption.
+ */
+/** Holds derived encryption and HMAC keys for field-level encryption. */
+declare class GeodeCipher {
+    private readonly encKey;
+    private readonly hmacKey;
+    /** @internal Use createCipher(). */
+    constructor(masterKey: Uint8Array);
+    /** Encrypt with AES-256-GCM, prepending a random nonce. */
+    encrypt(plaintext: Uint8Array): Buffer;
+    /** Decrypt a ciphertext produced by encrypt(). Throws on short input or auth failure. */
+    decrypt(ciphertext: Uint8Array): Buffer;
+    /** Encrypt a string, returning a base64-encoded result. */
+    encryptString(plaintext: string): string;
+    /** Base64-decode and decrypt, returning the original string. */
+    decryptString(encoded: string): string;
+    /**
+     * Compute HMAC-SHA256 of `data` using the derived HMAC key, returning a
+     * 64-char lowercase hex digest. Deterministic; use for equality lookups on
+     * encrypted fields.
+     */
+    hmacHex(data: string): string;
+}
+/** Create a GeodeCipher from a master key (>= 32 bytes). */
+declare function createCipher(masterKey: Uint8Array): GeodeCipher;
+
+export { AuthClient, BaseTransport, type BatchOptions, type BatchQuery, type BatchResult, type BatchSummary, BeginRequest, BeginResponse, type ClientOptions, type ColumnDef, ColumnDefinition, type ColumnInfo, CommitRequest, CommitResponse, ConfigError, Connection, ConnectionPool, type ConnectionState, type CreateRLSPolicyOptions, type CreateRoleOptions, type CreateUserOptions, DEFAULT_CHUNK_SIZE, DEFAULT_CONFORMANCE, DEFAULT_GRPC_PORT, DEFAULT_HELLO_NAME, DEFAULT_HELLO_VERSION, DEFAULT_MAX_WORKERS, DEFAULT_PAGE_SIZE, DEFAULT_PORT, type DSNScheme, DataPage, DriverError, ERR_BAD_CONN_MESSAGE, ERR_CLOSED_MESSAGE, ERR_INVALID_IDENT_MESSAGE, ERR_INVALID_STRING_MESSAGE, ERR_NO_ROWS_MESSAGE, ERR_NO_TX_MESSAGE, ERR_QUERY_IN_PROGRESS_MESSAGE, ERR_ROWS_CLOSED_MESSAGE, ERR_TX_DONE_MESSAGE, ERR_TX_IN_PROGRESS_MESSAGE, type EdgeDirection, type EdgePattern, EdgePatternBuilder, ErrBadConn, ErrClosed, ErrInvalidIdent, ErrInvalidString, ErrNoRows, ErrNoTx, ErrQueryInProgress, ErrRowsClosed, ErrTxDone, ErrTxInProgress, ExecuteRequest, ExecutionResponse, type ExplainOptions, type GQLEdge, type GQLId, type GQLNode, type GQLPath, type GQLRange, type GQLType, GQLValue, type GQLValueKind, GeodeCipher, GeodeClient, type GeodeConfig, type GeodeError, GrpcTransport, HelloRequest, HelloResponse, MAX_PAGE_SIZE, MAX_QUERY_LENGTH, MockTransport, type NodePattern, NodePatternBuilder, type OperationTiming, Param, type ParameterInfo, PatternBuilder, type PatternElement, type Permission, PingRequest, PingResponse, type PipelineExecutor, type PipelineTx, type PlanOperation, type PoolConfig, PredicateBuilder, type PredicateOp, PreparedStatement, type ProtoError, Row$1 as ProtoRow, type ProtoValue, PullRequest, PullResponse, QueryBuilder, type QueryOptions, type QueryParams, type QueryPlan, type QueryProfile, QueryResult, QueryResultIterator, QuicClientMessage, QuicServerMessage, QuicTransport, QuicTransport as QuicheTransport, type RLSPolicy, type RawEdge, type RetryPolicy, type Role, RollbackRequest, RollbackResponse, type Row, SUPPORTED_SCHEMES, SchemaDefinition, SecurityError, type SortDirection, StateError, type Statement, Status, StatusClass, type StatusClassType, Transaction, type Transport, TransportError, type TransportType, type User, batch, batchAll, batchExec, batchFirst, batchMap, batchParallel, buildBeginRequest, buildCommitRequest, buildExecuteRequest, buildHelloRequest, buildPingRequest, buildPullRequest, buildRollbackRequest, buildRollbackToRequest, buildSavepointRequest, buildTLSConfig, cloneConfig, createAuthClient, createCipher, createClient, createClientWithConfig, createTransport, decodeLengthPrefix, decodeQuicServerMessage, defaultConfig, defaultRetryPolicy, edge, encodeQuicClientMessage, encodeWithLengthPrefix, ensureProtoInitialized, explain, extractParameters, formatDSN, formatPlan, formatProfile, fromJSON, getAddress, getProtoPath, initProtoSync, isAuthError, isDriverError, isGeodeError, isRetryableError, isSentinelError, isSyntaxError, jsToProtoValue, node, parseDSN, parseGQLType, parseRow, parseSchemaFS, pattern, pipelineExec, predicate, prepare, profile, protoValueToJS, query, quoteIdent, quoteString, redactConfig, redactDSN, rowToObject, rowToRecord, sanitizeForLog, sanitizeGraphName, validateConfig, validateHostname, validatePageSize, validateParamName, validateParamValue, validatePort, validateQuery, validateSavepointName, withRetry, withTransaction };