@hpcc-js/comms 3.23.0 → 3.23.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hpcc-js/comms",
-    "version": "3.23.0",
+    "version": "3.23.1",
     "description": "hpcc-js - Communications",
     "type": "module",
     "main": "./dist/node/index.cjs",
@@ -53,27 +53,27 @@
         "coverage": "vitest run --coverage",
         "update": "npx --yes npm-check-updates -u -t minor",
         "update-major": "npx --yes npm-check-updates -u",
-        "wsdl-access": "node ./lib-esm/index.js -k --url=http://localhost:8010/ws_access?wsdl --outDir=./src/services/wsdl",
-        "wsdl-account": "node ./lib-esm/index.js -k --url=http://localhost:8010/Ws_Account?wsdl --outDir=./src/services/wsdl",
-        "wsdl-cloud": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsCloud?wsdl --outDir=./src/services/wsdl",
-        "wsdl-codesign": "node ./lib-esm/index.js -k --url=http://localhost:8010/ws_codesign?wsdl --outDir=./src/services/wsdl",
-        "wsdl-dali": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsDali?wsdl --outDir=./src/services/wsdl",
-        "wsdl-dfu": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsDfu?wsdl --outDir=./src/services/wsdl",
-        "wsdl-dfuxref": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsDFUXRef?wsdl --outDir=./src/services/wsdl",
-        "wsdl-elk": "node ./lib-esm/index.js -k --url=http://localhost:8010/ws_elk?wsdl --outDir=./src/services/wsdl",
-        "wsdl-esdlconfig": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsEsdlconfig?wsdl --outDir=./src/services/wsdl",
-        "wsdl-fileio": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsFileIO?wsdl --outDir=./src/services/wsdl",
-        "wsdl-filespray": "node ./lib-esm/index.js -k --url=http://localhost:8010/FileSpray?wsdl --outDir=./src/services/wsdl",
-        "wsdl-logaccess": "node ./lib-esm/index.js -k --url=http://localhost:8010/ws_logaccess?wsdl --outDir=./src/services/wsdl",
-        "wsdl-machine": "node ./lib-esm/index.js -k --url=http://localhost:8010/ws_machine?wsdl --outDir=./src/services/wsdl",
-        "wsdl-packageprocess": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsPackageProcess?wsdl --outDir=./src/services/wsdl",
-        "wsdl-sasha": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsSasha?wsdl --outDir=./src/services/wsdl",
-        "wsdl-smc": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsSMC?wsdl --outDir=./src/services/wsdl",
-        "wsdl-sql2": "node ./lib-esm/index.js -k --url=http://localhost:8510/WsSQL2?wsdl --outDir=./src/services/wsdl",
-        "wsdl-resources": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsResources?wsdl --outDir=./src/services/wsdl",
-        "wsdl-store": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsStore?wsdl --outDir=./src/services/wsdl",
-        "wsdl-topology": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsTopology?wsdl --outDir=./src/services/wsdl",
-        "wsdl-workunits": "node ./lib-esm/index.js -k --url=http://localhost:8010/WsWorkunits?wsdl --outDir=./src/services/wsdl",
+        "wsdl-access": "tsx ./utils/index.ts -k --url=http://localhost:8010/ws_access?wsdl --outDir=./src/services/wsdl",
+        "wsdl-account": "tsx ./utils/index.ts -k --url=http://localhost:8010/Ws_Account?wsdl --outDir=./src/services/wsdl",
+        "wsdl-cloud": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsCloud?wsdl --outDir=./src/services/wsdl",
+        "wsdl-codesign": "tsx ./utils/index.ts -k --url=http://localhost:8010/ws_codesign?wsdl --outDir=./src/services/wsdl",
+        "wsdl-dali": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsDali?wsdl --outDir=./src/services/wsdl",
+        "wsdl-dfu": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsDfu?wsdl --outDir=./src/services/wsdl",
+        "wsdl-dfuxref": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsDFUXRef?wsdl --outDir=./src/services/wsdl",
+        "wsdl-elk": "tsx ./utils/index.ts -k --url=http://localhost:8010/ws_elk?wsdl --outDir=./src/services/wsdl",
+        "wsdl-esdlconfig": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsEsdlconfig?wsdl --outDir=./src/services/wsdl",
+        "wsdl-fileio": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsFileIO?wsdl --outDir=./src/services/wsdl",
+        "wsdl-filespray": "tsx ./utils/index.ts -k --url=http://localhost:8010/FileSpray?wsdl --outDir=./src/services/wsdl",
+        "wsdl-logaccess": "tsx ./utils/index.ts -k --url=http://localhost:8010/ws_logaccess?wsdl --outDir=./src/services/wsdl",
+        "wsdl-machine": "tsx ./utils/index.ts -k --url=http://localhost:8010/ws_machine?wsdl --outDir=./src/services/wsdl",
+        "wsdl-packageprocess": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsPackageProcess?wsdl --outDir=./src/services/wsdl",
+        "wsdl-sasha": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsSasha?wsdl --outDir=./src/services/wsdl",
+        "wsdl-smc": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsSMC?wsdl --outDir=./src/services/wsdl",
+        "wsdl-sql2": "tsx ./utils/index.ts -k --url=http://localhost:8510/WsSQL2?wsdl --outDir=./src/services/wsdl",
+        "wsdl-resources": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsResources?wsdl --outDir=./src/services/wsdl",
+        "wsdl-store": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsStore?wsdl --outDir=./src/services/wsdl",
+        "wsdl-topology": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsTopology?wsdl --outDir=./src/services/wsdl",
+        "wsdl-workunits": "tsx ./utils/index.ts -k --url=http://localhost:8010/WsWorkunits?wsdl --outDir=./src/services/wsdl",
         "wsdl-all": "npm-run-all --aggregate-output -c --serial build --parallel wsdl-*"
     },
     "dependencies": {
@@ -112,5 +112,5 @@
         "esp",
         "HPCC-Platform"
     ],
-    "gitHead": "8c3937e3502133c20cf6e5dc3a1c3faef890103f"
+    "gitHead": "099b2ba95683821419933cbb439aca232371a2b1"
 }

package/src/ecl/sql2.ts

@@ -16,13 +16,13 @@ function checkExceptions(response: { Exceptions?: WsSQL2.Exceptions }): void {
     }
 }
 
-function rowsFrom(response: { Rows?: string }): SQLValue[][] {
-    if (typeof response.Rows !== "string") {
-        throw new Error("WsSQL2 response is missing Rows");
+function rowsFrom(response: { RowsJSON?: string }): SQLValue[][] {
+    if (typeof response.RowsJSON !== "string") {
+        throw new Error("WsSQL2 response is missing RowsJSON");
     }
     let rows: unknown;
     try {
-        rows = JSON.parse(response.Rows);
+        rows = JSON.parse(response.RowsJSON);
     } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         throw Object.assign(new Error(`Error parsing WsSQL2 Rows JSON '${message}'`), { cause: error });
@@ -72,17 +72,17 @@ export class SQLConnection {
     async explainQuery(sql: string): Promise<WsSQL2.ExplainQueryResponse> {
         this.checkOpen();
         if (!sql.trim()) throw new Error("SQL text is required");
-        const response = await this.service.ExplainQuery({ SqlText: sql });
+        const response = await this.service.ExplainQuery({ SQLText: sql });
         checkExceptions(response);
         return response;
     }
 
-    async logicalFileMeta(logicalName: string): Promise<WsSQL2.LogicalFileMeta | undefined> {
+    async logicalFileMeta(logicalName: string): Promise<WsSQL2.LogicalFileMetadata | undefined> {
         this.checkOpen();
         if (!logicalName.trim()) throw new Error("Logical file name is required");
-        const response = await this.service.LogicalFileMeta({ LogicalName: logicalName });
+        const response = await this.service.LogicalFileMetadata({ LogicalName: logicalName });
         checkExceptions(response);
-        return response.LogicalFileMeta;
+        return response.LogicalFileMetadata;
     }
 
     async ping(): Promise<boolean> {
@@ -94,7 +94,7 @@ export class SQLConnection {
     async splitQuery(sql: string): Promise<string[]> {
         this.checkOpen();
         if (!sql.trim()) return [];
-        const response = await this.service.SplitQuery({ SqlText: sql });
+        const response = await this.service.SplitQuery({ SQLText: sql });
         checkExceptions(response);
         const statements = response.Statements?.Statement ?? [];
         if (!Array.isArray(statements) || !statements.every(statement => typeof statement === "string")) {
@@ -171,7 +171,7 @@ export class SQLStatement {
         this.result = undefined;
         if (this.closed) throw new Error("SQL statement is closed");
         const response = await this.service.ExecuteQuery({
-            SqlText: sql, IncludeResultSetMetadata: true
+            SQLText: sql, IncludeResultSetMetadata: true
         });
         const columns = response.ResultSetMetadata?.Column;
         const result = response.CursorId ? new SQLResultSet(this.service, columns ?? [], response.CursorId, this.fetchSize) : undefined;
@@ -276,7 +276,7 @@ export class SQLResultSet {
             while (++this.index >= this.rows.length) {
                 this.checkOpen();
                 if (this.complete) return false;
-                const response = await this.service.FetchResultSet({ CursorId: this.cursor, FetchSize: this.fetchSize });
+                const response = await this.service.FetchResultSet({ CursorId: this.cursor, RowCount: this.fetchSize });
                 checkExceptions(response);
                 if (typeof response.Complete !== "boolean") throw new Error("WsSQL2 fetch response is missing Complete");
                 const rows = rowsFrom(response);

package/src/services/wsSQL2.ts

@@ -1,4 +1,4 @@
-import { SQL2ServiceBase, WsSQL2 } from "./wsdl/WsSQL2/v1.00/WsSQL2.ts";
+import { SQL2ServiceBase, WsSQL2 } from "./wsdl/WsSQL2/v1.01/WsSQL2.ts";
 
 export {
     type WsSQL2

package/src/services/wsdl/WsSQL2/current/WsSQL2.ts

@@ -30,7 +30,7 @@ export namespace WsSQL2 {
     }
 
     export interface ExecuteQueryRequest {
-        SqlText?: string;
+        SQLText?: string;
         IncludeRuntimeGraph?: boolean;
         IncludeResultSetMetadata?: boolean;
         IncludeDebug?: boolean;
@@ -56,19 +56,19 @@ export namespace WsSQL2 {
     }
 
     export interface ExplainQueryRequest {
-        SqlText?: string;
+        SQLText?: string;
     }
 
     export interface ExplainQueryResponse {
         Exceptions?: Exceptions;
         Plan?: string;
-        PlanJson?: string;
+        PlanJSON?: string;
         ResultSetMetadata?: ResultSetMetadata;
     }
 
     export interface FetchResultSetRequest {
         CursorId?: string;
-        FetchSize?: unsignedInt;
+        RowCount?: unsignedInt;
     }
 
     export interface Start {
@@ -128,19 +128,20 @@ export namespace WsSQL2 {
 
     export interface FetchResultSetResponse {
         Exceptions?: Exceptions;
-        Rows?: string;
+        RowsJSON?: string;
+        RowCount?: unsignedInt;
         Complete?: boolean;
         ExecuteMs?: double;
         RuntimeGraph?: string;
-        RuntimeGraphJson?: string;
+        RuntimeGraphJSON?: string;
         DebugInfo?: DebugInfo;
     }
 
-    export interface LogicalFileMetaRequest {
+    export interface LogicalFileMetadataRequest {
         LogicalName?: string;
     }
 
-    export interface LogicalFileMeta {
+    export interface LogicalFileMetadata {
         Version?: unsignedInt;
         LogicalName?: string;
         Kind?: string;
@@ -157,9 +158,9 @@ export namespace WsSQL2 {
         SampleSQL?: string;
     }
 
-    export interface LogicalFileMetaResponse {
+    export interface LogicalFileMetadataResponse {
         Exceptions?: Exceptions;
-        LogicalFileMeta?: LogicalFileMeta;
+        LogicalFileMetadata?: LogicalFileMetadata;
     }
 
     export interface WsSQL2PingRequest {
@@ -171,7 +172,7 @@ export namespace WsSQL2 {
     }
 
     export interface SplitQueryRequest {
-        SqlText?: string;
+        SQLText?: string;
     }
 
     export interface Statements {
@@ -188,7 +189,7 @@ export namespace WsSQL2 {
 export class SQL2ServiceBase extends Service {
 
     constructor(optsConnection: IOptions | IConnection) {
-        super(optsConnection, "WsSQL2", "1.00");
+        super(optsConnection, "WsSQL2", "1.01");
     }
 
     CloseResultSet(request: WsSQL2.CloseResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.CloseResultSetResponse> {
@@ -207,8 +208,8 @@ export class SQL2ServiceBase extends Service {
         return this._connection.send("FetchResultSet", request, "json", false, abortSignal, "FetchResultSetResponse");
     }
 
-    LogicalFileMeta(request: WsSQL2.LogicalFileMetaRequest, abortSignal?: AbortSignal): Promise<WsSQL2.LogicalFileMetaResponse> {
-        return this._connection.send("LogicalFileMeta", request, "json", false, abortSignal, "LogicalFileMetaResponse");
+    LogicalFileMetadata(request: WsSQL2.LogicalFileMetadataRequest, abortSignal?: AbortSignal): Promise<WsSQL2.LogicalFileMetadataResponse> {
+        return this._connection.send("LogicalFileMetadata", request, "json", false, abortSignal, "LogicalFileMetadataResponse");
     }
 
     Ping(request: WsSQL2.WsSQL2PingRequest, abortSignal?: AbortSignal): Promise<WsSQL2.WsSQL2PingResponse> {

package/src/services/wsdl/WsSQL2/v1.01/WsSQL2.ts

@@ -0,0 +1,223 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsSQL2 {
+
+    export type double = number;
+    export type unsignedInt = number;
+    export type long = number;
+    export type uint64 = number;
+
+    export interface CloseResultSetRequest {
+        CursorId?: string;
+    }
+
+    export interface Exception {
+        Code?: string;
+        Audience?: string;
+        Source?: string;
+        Message?: string;
+    }
+
+    export interface Exceptions {
+        Source?: string;
+        Exception?: Exception[];
+    }
+
+    export interface CloseResultSetResponse {
+        Exceptions?: Exceptions;
+        Closed?: boolean;
+    }
+
+    export interface ExecuteQueryRequest {
+        SQLText?: string;
+        IncludeRuntimeGraph?: boolean;
+        IncludeResultSetMetadata?: boolean;
+        IncludeDebug?: boolean;
+    }
+
+    export interface Column {
+        ColumnLabel?: string;
+        ColumnTypeName?: string;
+        Precision?: unsignedInt;
+        Scale?: unsignedInt;
+    }
+
+    export interface ResultSetMetadata {
+        Column?: Column[];
+    }
+
+    export interface ExecuteQueryResponse {
+        Exceptions?: Exceptions;
+        CursorId?: string;
+        InitMs?: double;
+        PrepareMs?: double;
+        ResultSetMetadata?: ResultSetMetadata;
+    }
+
+    export interface ExplainQueryRequest {
+        SQLText?: string;
+    }
+
+    export interface ExplainQueryResponse {
+        Exceptions?: Exceptions;
+        Plan?: string;
+        PlanJSON?: string;
+        ResultSetMetadata?: ResultSetMetadata;
+    }
+
+    export interface FetchResultSetRequest {
+        CursorId?: string;
+        RowCount?: unsignedInt;
+    }
+
+    export interface Start {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface Current {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface Released {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface Retained {
+        DuckDBUsedBytes?: long;
+        DuckDBTempBytes?: long;
+        HeapInUseBytes?: long;
+        ResidentBytes?: long;
+        PeakResidentBytes?: long;
+    }
+
+    export interface ScanObjectsCreated {
+        BindData?: long;
+        GlobalStates?: long;
+        LocalStates?: long;
+    }
+
+    export interface ScanObjectsLive {
+        BindData?: long;
+        GlobalStates?: long;
+        LocalStates?: long;
+    }
+
+    export interface DebugInfo {
+        Start?: Start;
+        Current?: Current;
+        Released?: Released;
+        Retained?: Retained;
+        ScanObjectsCreated?: ScanObjectsCreated;
+        ScanObjectsLive?: ScanObjectsLive;
+        LeakCheck?: string;
+        LeakCheckDetail?: string;
+    }
+
+    export interface FetchResultSetResponse {
+        Exceptions?: Exceptions;
+        RowsJSON?: string;
+        RowCount?: unsignedInt;
+        Complete?: boolean;
+        ExecuteMs?: double;
+        RuntimeGraph?: string;
+        RuntimeGraphJSON?: string;
+        DebugInfo?: DebugInfo;
+    }
+
+    export interface LogicalFileMetadataRequest {
+        LogicalName?: string;
+    }
+
+    export interface LogicalFileMetadata {
+        Version?: unsignedInt;
+        LogicalName?: string;
+        Kind?: string;
+        Format?: string;
+        Grouped?: boolean;
+        FormatCrc?: unsignedInt;
+        RecordTranslationMode?: unsignedInt;
+        Modified?: long;
+        RecordCount?: uint64;
+        FormatOptions?: string;
+        ProviderOptions?: string;
+        EclRecord?: string;
+        FileParts?: string;
+        SampleSQL?: string;
+    }
+
+    export interface LogicalFileMetadataResponse {
+        Exceptions?: Exceptions;
+        LogicalFileMetadata?: LogicalFileMetadata;
+    }
+
+    export interface WsSQL2PingRequest {
+
+    }
+
+    export interface WsSQL2PingResponse {
+
+    }
+
+    export interface SplitQueryRequest {
+        SQLText?: string;
+    }
+
+    export interface Statements {
+        Statement?: string[];
+    }
+
+    export interface SplitQueryResponse {
+        Exceptions?: Exceptions;
+        Statements?: Statements;
+    }
+
+}
+
+export class SQL2ServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsSQL2", "1.01");
+    }
+
+    CloseResultSet(request: WsSQL2.CloseResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.CloseResultSetResponse> {
+        return this._connection.send("CloseResultSet", request, "json", false, abortSignal, "CloseResultSetResponse");
+    }
+
+    ExecuteQuery(request: WsSQL2.ExecuteQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExecuteQueryResponse> {
+        return this._connection.send("ExecuteQuery", request, "json", false, abortSignal, "ExecuteQueryResponse");
+    }
+
+    ExplainQuery(request: WsSQL2.ExplainQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExplainQueryResponse> {
+        return this._connection.send("ExplainQuery", request, "json", false, abortSignal, "ExplainQueryResponse");
+    }
+
+    FetchResultSet(request: WsSQL2.FetchResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.FetchResultSetResponse> {
+        return this._connection.send("FetchResultSet", request, "json", false, abortSignal, "FetchResultSetResponse");
+    }
+
+    LogicalFileMetadata(request: WsSQL2.LogicalFileMetadataRequest, abortSignal?: AbortSignal): Promise<WsSQL2.LogicalFileMetadataResponse> {
+        return this._connection.send("LogicalFileMetadata", request, "json", false, abortSignal, "LogicalFileMetadataResponse");
+    }
+
+    Ping(request: WsSQL2.WsSQL2PingRequest, abortSignal?: AbortSignal): Promise<WsSQL2.WsSQL2PingResponse> {
+        return this._connection.send("Ping", request, "json", false, abortSignal, "WsSQL2PingResponse");
+    }
+
+    SplitQuery(request: WsSQL2.SplitQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.SplitQueryResponse> {
+        return this._connection.send("SplitQuery", request, "json", false, abortSignal, "SplitQueryResponse");
+    }
+
+}

package/types/ecl/sql2.d.ts

@@ -18,7 +18,7 @@ export declare class SQLConnection {
     createStatement(): SQLStatement;
     queryRows(sql: string, fetchSize?: number): Promise<SQLRow[]>;
     explainQuery(sql: string): Promise<WsSQL2.ExplainQueryResponse>;
-    logicalFileMeta(logicalName: string): Promise<WsSQL2.LogicalFileMeta | undefined>;
+    logicalFileMeta(logicalName: string): Promise<WsSQL2.LogicalFileMetadata | undefined>;
     ping(): Promise<boolean>;
     splitQuery(sql: string): Promise<string[]>;
     close(): Promise<void>;

package/types/services/wsSQL2.d.ts

@@ -1,4 +1,4 @@
-import { SQL2ServiceBase, WsSQL2 } from "./wsdl/WsSQL2/v1.00/WsSQL2.ts";
+import { SQL2ServiceBase, WsSQL2 } from "./wsdl/WsSQL2/v1.01/WsSQL2.ts";
 export { type WsSQL2 };
 export declare class SQL2Service extends SQL2ServiceBase {
 }

package/types/services/wsdl/WsSQL2/{v1.00 → v1.01}/WsSQL2.d.ts

@@ -23,7 +23,7 @@ export declare namespace WsSQL2 {
         Closed?: boolean;
     }
     interface ExecuteQueryRequest {
-        SqlText?: string;
+        SQLText?: string;
         IncludeRuntimeGraph?: boolean;
         IncludeResultSetMetadata?: boolean;
         IncludeDebug?: boolean;
@@ -45,17 +45,17 @@ export declare namespace WsSQL2 {
         ResultSetMetadata?: ResultSetMetadata;
     }
     interface ExplainQueryRequest {
-        SqlText?: string;
+        SQLText?: string;
     }
     interface ExplainQueryResponse {
         Exceptions?: Exceptions;
         Plan?: string;
-        PlanJson?: string;
+        PlanJSON?: string;
         ResultSetMetadata?: ResultSetMetadata;
     }
     interface FetchResultSetRequest {
         CursorId?: string;
-        FetchSize?: unsignedInt;
+        RowCount?: unsignedInt;
     }
     interface Start {
         DuckDBUsedBytes?: long;
@@ -107,17 +107,18 @@ export declare namespace WsSQL2 {
     }
     interface FetchResultSetResponse {
         Exceptions?: Exceptions;
-        Rows?: string;
+        RowsJSON?: string;
+        RowCount?: unsignedInt;
         Complete?: boolean;
         ExecuteMs?: double;
         RuntimeGraph?: string;
-        RuntimeGraphJson?: string;
+        RuntimeGraphJSON?: string;
         DebugInfo?: DebugInfo;
     }
-    interface LogicalFileMetaRequest {
+    interface LogicalFileMetadataRequest {
         LogicalName?: string;
     }
-    interface LogicalFileMeta {
+    interface LogicalFileMetadata {
         Version?: unsignedInt;
         LogicalName?: string;
         Kind?: string;
@@ -133,16 +134,16 @@ export declare namespace WsSQL2 {
         FileParts?: string;
         SampleSQL?: string;
     }
-    interface LogicalFileMetaResponse {
+    interface LogicalFileMetadataResponse {
         Exceptions?: Exceptions;
-        LogicalFileMeta?: LogicalFileMeta;
+        LogicalFileMetadata?: LogicalFileMetadata;
     }
     interface WsSQL2PingRequest {
     }
     interface WsSQL2PingResponse {
     }
     interface SplitQueryRequest {
-        SqlText?: string;
+        SQLText?: string;
     }
     interface Statements {
         Statement?: string[];
@@ -158,7 +159,7 @@ export declare class SQL2ServiceBase extends Service {
     ExecuteQuery(request: WsSQL2.ExecuteQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExecuteQueryResponse>;
     ExplainQuery(request: WsSQL2.ExplainQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.ExplainQueryResponse>;
     FetchResultSet(request: WsSQL2.FetchResultSetRequest, abortSignal?: AbortSignal): Promise<WsSQL2.FetchResultSetResponse>;
-    LogicalFileMeta(request: WsSQL2.LogicalFileMetaRequest, abortSignal?: AbortSignal): Promise<WsSQL2.LogicalFileMetaResponse>;
+    LogicalFileMetadata(request: WsSQL2.LogicalFileMetadataRequest, abortSignal?: AbortSignal): Promise<WsSQL2.LogicalFileMetadataResponse>;
     Ping(request: WsSQL2.WsSQL2PingRequest, abortSignal?: AbortSignal): Promise<WsSQL2.WsSQL2PingResponse>;
     SplitQuery(request: WsSQL2.SplitQueryRequest, abortSignal?: AbortSignal): Promise<WsSQL2.SplitQueryResponse>;
 }