@dynatrace-sdk/client-query 1.21.1 → 1.21.2

package/dynatrace-metadata.json

@@ -1,9 +1,9 @@
 {
   "dynagen": {
-    "version": "0.19.3",
+    "version": "0.19.9",
     "template": {
       "name": "@dynatrace-sdk/template-typescript-client",
-      "version": "0.34.0"
+      "version": "0.34.4"
     },
     "featureFlags": {
       "typeguards": true

package/esm/index.js

@@ -20,12 +20,6 @@ import {
   isHttpClientAbortError,
   isHttpClientResponseError
 } from "@dynatrace-sdk/http-client";
-import {
-  apiGatewayErrorsHandler,
-  getErrorMessage,
-  transformRequest,
-  transformResponse
-} from "@dynatrace-sdk/shared-client-utils";
 import {
   ApiClientError,
   ClientRequestError as ClientRequestError2,
@@ -33,6 +27,15 @@ import {
   isInvalidResponseError
 } from "@dynatrace-sdk/shared-errors";
 
+// packages/client/query/src/lib/error-envelopes/api-gateway-errors-handler.ts
+import { ApiGatewayError } from "@dynatrace-sdk/shared-errors";
+async function apiGatewayErrorsHandler(response) {
+  if (response.headers?.["dynatrace-response-source"] === "API Gateway") {
+    const responseBody = await response.body("json");
+    throw new ApiGatewayError(response, responseBody);
+  }
+}
+
 // packages/client/query/src/lib/error-envelopes/error-envelope-error.ts
 import { ClientRequestError } from "@dynatrace-sdk/shared-errors";
 var ErrorEnvelopeError = class extends ClientRequestError {
@@ -42,6 +45,198 @@ function isErrorEnvelopeError(e) {
   return e?.isApiClientError === true && e?.isClientRequestError === true && e?.isErrorEnvelopeError === true && e instanceof Error;
 }
 
+// packages/client/query/src/lib/error-envelopes/get-error-message.ts
+function serializeData(data) {
+  try {
+    return JSON.stringify(data);
+  } catch (e) {
+    return String(data);
+  }
+}
+function getMessagesFromErrorDetails(details) {
+  const messages = [];
+  Object.entries(details).forEach(([name, data]) => {
+    if (!data)
+      return;
+    const serializedData = serializeData(data);
+    switch (name) {
+      case "missingScopes":
+        messages.push(`Missing scopes: ${serializedData}`);
+        break;
+      default:
+        messages.push(`${name}: ${serializedData}`);
+    }
+  }, []);
+  return messages;
+}
+function getErrorMessage(errorBody, defaultMessage) {
+  const error = errorBody;
+  const msg = error?.error?.message || defaultMessage;
+  const details = error?.error?.details || {};
+  return [msg, ...getMessagesFromErrorDetails(details)].join(". ");
+}
+
+// packages/client/query/src/lib/utils/transformations.ts
+var defaultRuleConfig = {
+  force: false,
+  datetime: false
+};
+function mergeKeys(key1, key2) {
+  if (!key1)
+    return key2;
+  if (!key2)
+    return key1;
+  return `${key1}.${key2}`;
+}
+function matchKey(key, rules, cache) {
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+  for (const rule of rules) {
+    const pattern = Array.isArray(rule) ? rule[0] : rule;
+    const config = Array.isArray(rule) ? rule[1] : defaultRuleConfig;
+    if (key === pattern) {
+      const result = [pattern, config];
+      cache.set(key, result);
+      return result;
+    }
+    let i = 0;
+    let j = 0;
+    const keyLen = key.length;
+    const patternLen = pattern.length;
+    let isMatch = true;
+    while (i < keyLen && j < patternLen) {
+      let keyPartEnd = key.indexOf(".", i);
+      let patternPartEnd = pattern.indexOf(".", j);
+      if (keyPartEnd === -1)
+        keyPartEnd = keyLen;
+      if (patternPartEnd === -1)
+        patternPartEnd = patternLen;
+      const keyPart = key.slice(i, keyPartEnd);
+      const patternPart = pattern.slice(j, patternPartEnd);
+      if (patternPart !== "*" && patternPart !== "**" && keyPart !== patternPart) {
+        isMatch = false;
+        break;
+      }
+      i = keyPartEnd + 1;
+      j = patternPartEnd + 1;
+    }
+    if (isMatch) {
+      if (j < patternLen) {
+        const remaining = pattern.slice(j);
+        if (remaining !== "**" && remaining !== "*") {
+          isMatch = false;
+        }
+      }
+      if (i < keyLen && pattern.slice(j - 1) !== "**") {
+        isMatch = false;
+      }
+    }
+    if (isMatch) {
+      const result = [pattern, config];
+      cache.set(key, result);
+      return result;
+    }
+  }
+  cache.set(key, null);
+  return null;
+}
+var potentialMatchForRoot = (pattern, key) => pattern.startsWith(key) || pattern.startsWith("*") || pattern.startsWith("**");
+var potentialMatch = (pattern, key) => pattern.startsWith(key) || pattern.includes("*") || pattern.includes("**");
+function partialMatch(key, keyPatterns) {
+  const keyPatternsLen = keyPatterns.length;
+  if (!key.includes(".")) {
+    for (let i = 0; i < keyPatternsLen; i++) {
+      const pattern = keyPatterns[i];
+      if (potentialMatchForRoot(pattern, key))
+        return true;
+    }
+    return false;
+  }
+  let dotIndex = -1;
+  let currentKeyEnd = 0;
+  while ((dotIndex = key.indexOf(".", currentKeyEnd)) !== -1) {
+    const currentKey = key.slice(0, dotIndex);
+    const isRoot = !currentKey.includes(".");
+    for (let i = 0; i < keyPatternsLen; i++) {
+      const pattern = keyPatterns[i];
+      if (isRoot) {
+        if (potentialMatchForRoot(pattern, currentKey))
+          return true;
+      } else if (potentialMatch(pattern, currentKey))
+        return true;
+    }
+    currentKeyEnd = dotIndex + 1;
+  }
+  for (let i = 0; i < keyPatternsLen; i++) {
+    const pattern = keyPatterns[i];
+    if (potentialMatch(pattern, key))
+      return true;
+  }
+  return false;
+}
+var dateTimePattern = /^(\d{4}-\d{2}-\d{2})(T\d{2}:\d{2}:\d{2}(?:\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/i;
+function isDateLike(value) {
+  if (typeof value === "string") {
+    return dateTimePattern.test(value);
+  }
+  return false;
+}
+function transformValue(value, rules, direction) {
+  const { force, datetime } = rules;
+  if (direction === "to") {
+    return force || isDateLike(value) ? new Date(value) : value;
+  }
+  if (value instanceof Date) {
+    const iso = value.toISOString();
+    return datetime ? iso : iso.split("T")[0];
+  }
+  return value;
+}
+function walk(obj, direction, rules, rulesCache, keyPatterns, currentKey = "") {
+  if (rules.length <= 0) {
+    return obj;
+  }
+  if (!partialMatch(currentKey, keyPatterns)) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    const match = matchKey(currentKey, rules, rulesCache);
+    obj.forEach((item, idx) => {
+      if (typeof item === "object" && item !== null) {
+        walk(item, direction, rules, rulesCache, keyPatterns, currentKey);
+      } else if (match) {
+        obj[idx] = transformValue(obj[idx], match[1], direction);
+      }
+    });
+  }
+  if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+    for (const key of Object.keys(obj)) {
+      const mergedKey = mergeKeys(currentKey, key);
+      const match = matchKey(mergedKey, rules, rulesCache);
+      if (match) {
+        obj[key] = transformValue(obj[key], match[1], direction);
+      }
+      walk(obj[key], direction, rules, rulesCache, keyPatterns, mergedKey);
+    }
+  }
+  return obj;
+}
+function flattenKeyPatterns(keyPatterns) {
+  return keyPatterns.map((k) => Array.isArray(k) ? k[0] : k);
+}
+function transform(direction, object, rules) {
+  const flatKeyPatterns = flattenKeyPatterns(rules);
+  const rulesCache = /* @__PURE__ */ new Map();
+  return walk(object, direction, rules, rulesCache, flatKeyPatterns);
+}
+function transformRequest(object, rules) {
+  return transform("from", object, rules);
+}
+function transformResponse(object, rules) {
+  return transform("to", object, rules);
+}
+
 // packages/client/query/src/lib/apis/query-assistance-api.ts
 var QueryAssistanceClient = class {
   httpClient;
@@ -753,15 +948,6 @@ import {
   isHttpClientAbortError as isHttpClientAbortError2,
   isHttpClientResponseError as isHttpClientResponseError2
 } from "@dynatrace-sdk/http-client";
-import {
-  Encoding,
-  apiGatewayErrorsHandler as apiGatewayErrorsHandler2,
-  getErrorMessage as getErrorMessage2,
-  mimeTypeToEncoding,
-  toQueryString,
-  transformRequest as transformRequest2,
-  transformResponse as transformResponse2
-} from "@dynatrace-sdk/shared-client-utils";
 import {
   ApiClientError as ApiClientError2,
   ClientRequestError as ClientRequestError3,
@@ -779,6 +965,55 @@ function isInsufficientPermission(e) {
   return e?.isApiClientError === true && e?.isClientRequestError === true && e?.isErrorEnvelopeError === true && e?.isInsufficientPermission === true && e instanceof Error;
 }
 
+// packages/client/query/src/lib/utils/encoding.ts
+function mimeTypeToEncoding(mimeType, defaultEncoding) {
+  const shortMimeType = mimeType.split(";")[0];
+  switch (shortMimeType) {
+    case "application/json":
+    case "application/cloudevent+json":
+    case "application/cloudevent-batch+json":
+      return "json" /* Json */;
+    case "text/plain":
+      return "text" /* Text */;
+    case "application/octet-stream":
+      return "binary" /* Binary */;
+    case "multipart/form-data":
+      return "form-data" /* FormData */;
+    default:
+      if (defaultEncoding)
+        return defaultEncoding;
+      else
+        throw new Error(`${shortMimeType} mime type is not yet supported`);
+  }
+}
+
+// packages/client/query/src/lib/utils/url-helpers.ts
+var encodeQueryParam = (key, value) => {
+  const encodedKey = encodeURIComponent(key);
+  return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : String(value))}`;
+};
+var addExplodedArrayQueryParam = (query, key) => {
+  const arrayValue = query[key];
+  return arrayValue.map((value) => encodeQueryParam(key, value)).join("&");
+};
+var addNonExplodedArrayQueryParams = (query, key) => {
+  const encodedKey = encodeURIComponent(key);
+  const encodedParamsList = query[key].map((value) => encodeURIComponent(typeof value === "number" ? value : String(value))).join(",");
+  return `${encodedKey}=${encodedParamsList}`;
+};
+var addQueryParam = (query, key) => encodeQueryParam(key, query[key]);
+var arrayQueryParams = (query, key, explode) => {
+  return explode ? addExplodedArrayQueryParam(query, key) : addNonExplodedArrayQueryParams(query, key);
+};
+var toQueryString = (rawQuery, flags = {}) => {
+  const query = rawQuery || {};
+  const keys = Object.keys(query).filter((key) => typeof query[key] !== "undefined");
+  const queryString = keys.map(
+    (key) => Array.isArray(query[key]) ? arrayQueryParams(query, key, flags.explode?.hasOwnProperty(key) ? flags.explode[key] : true) : addQueryParam(query, key)
+  ).join("&");
+  return queryString ? `?${queryString}` : "";
+};
+
 // packages/client/query/src/lib/apis/query-execution-api.ts
 var QueryExecutionClient = class {
   httpClient;
@@ -873,7 +1108,7 @@ var QueryExecutionClient = class {
       });
       const responseValue = await response.body("json");
       try {
-        return this.shouldTransformDates ? transformResponse2(responseValue, [
+        return this.shouldTransformDates ? transformResponse(responseValue, [
           ["result.records.*.start", { datetime: true }],
           ["result.records.*.end", { datetime: true }],
           ["result.records.**.start", { datetime: true }],
@@ -901,17 +1136,17 @@ var QueryExecutionClient = class {
         throw new ApiClientError2("UnexpectedError", "Unexpected error", e);
       }
       const response = e.response;
-      await apiGatewayErrorsHandler2(response);
+      await apiGatewayErrorsHandler(response);
       switch (response.status) {
         case 400: {
           const responseValue = await response.body("json");
           try {
-            const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+            const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
             throw new ErrorEnvelopeError(
               `400`,
               response,
               errorBody,
-              getErrorMessage2(
+              getErrorMessage(
                 errorBody,
                 "The supplied request is wrong. Either the query itself or other parameters are wrong."
               ),
@@ -933,24 +1168,24 @@ var QueryExecutionClient = class {
         }
         case 410: {
           const contentType = response.headers["content-type"];
-          const encoding = mimeTypeToEncoding(contentType, Encoding.Text);
+          const encoding = mimeTypeToEncoding(contentType, "text" /* Text */);
           const responseValue = await response.body(encoding);
           throw new ClientRequestError3(
             `410`,
             response,
             responseValue,
-            getErrorMessage2(responseValue, `The query for the given request-token is not available anymore.`)
+            getErrorMessage(responseValue, `The query for the given request-token is not available anymore.`)
           );
         }
         case 500: {
           const responseValue = await response.body("json");
           try {
-            const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+            const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
             throw new ErrorEnvelopeError(
               `500`,
               response,
               errorBody,
-              getErrorMessage2(errorBody, "An internal server error has occurred."),
+              getErrorMessage(errorBody, "An internal server error has occurred."),
               e
             );
           } catch (err) {
@@ -974,7 +1209,7 @@ var QueryExecutionClient = class {
               `${response.status}`,
               response,
               responseValue,
-              getErrorMessage2(
+              getErrorMessage(
                 responseValue,
                 `Unexpected api response: code=${response.status} body="${responseValue}"`
               ),
@@ -1059,7 +1294,7 @@ var QueryExecutionClient = class {
     if (!config) {
       throw new ApiClientError2("API client error", "API client call is missing mandatory config parameter");
     }
-    const encodedBody = this.shouldTransformDates ? transformRequest2(config.body, []) : config.body;
+    const encodedBody = this.shouldTransformDates ? transformRequest(config.body, []) : config.body;
     const query = toQueryString({ enrich: config.enrich });
     const headerParameters = {
       ...config.dtClientContext !== void 0 && { "dt-client-context": String(config.dtClientContext) },
@@ -1087,7 +1322,7 @@ var QueryExecutionClient = class {
         case 200: {
           const responseValue = await response.body("json");
           try {
-            return this.shouldTransformDates ? transformResponse2(responseValue, [
+            return this.shouldTransformDates ? transformResponse(responseValue, [
               ["result.records.*.start", { datetime: true }],
               ["result.records.*.end", { datetime: true }],
               ["result.records.**.start", { datetime: true }],
@@ -1111,7 +1346,7 @@ var QueryExecutionClient = class {
         case 202: {
           const responseValue = await response.body("json");
           try {
-            return this.shouldTransformDates ? transformResponse2(responseValue, [
+            return this.shouldTransformDates ? transformResponse(responseValue, [
               ["result.records.*.start", { datetime: true }],
               ["result.records.*.end", { datetime: true }],
               ["result.records.**.start", { datetime: true }],
@@ -1139,7 +1374,7 @@ var QueryExecutionClient = class {
               `${response.status}`,
               response,
               responseValue,
-              getErrorMessage2(
+              getErrorMessage(
                 responseValue,
                 `Unexpected api response: code=${response.status} body="${responseValue}"`
               )
@@ -1168,17 +1403,17 @@ var QueryExecutionClient = class {
         throw new ApiClientError2("UnexpectedError", "Unexpected error", e);
       }
       const response = e.response;
-      await apiGatewayErrorsHandler2(response);
+      await apiGatewayErrorsHandler(response);
       switch (response.status) {
         case 400: {
           const responseValue = await response.body("json");
           try {
-            const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+            const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
             throw new ErrorEnvelopeError(
               `400`,
               response,
               errorBody,
-              getErrorMessage2(
+              getErrorMessage(
                 errorBody,
                 "The supplied request is wrong. Either the query itself or other parameters are wrong."
               ),
@@ -1201,12 +1436,12 @@ var QueryExecutionClient = class {
         case 403: {
           const responseValue = await response.body("json");
           try {
-            const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+            const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
             throw new InsufficientPermission(
               `403`,
               response,
               errorBody,
-              getErrorMessage2(errorBody, "Insufficient permissions."),
+              getErrorMessage(errorBody, "Insufficient permissions."),
               e
             );
           } catch (err) {
@@ -1226,12 +1461,12 @@ var QueryExecutionClient = class {
         case 429: {
           const responseValue = await response.body("json");
           try {
-            const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+            const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
             throw new ErrorEnvelopeError(
               `429`,
               response,
               errorBody,
-              getErrorMessage2(errorBody, "Too many requests."),
+              getErrorMessage(errorBody, "Too many requests."),
               e
             );
           } catch (err) {
@@ -1251,12 +1486,12 @@ var QueryExecutionClient = class {
         case 500: {
           const responseValue = await response.body("json");
           try {
-            const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+            const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
             throw new ErrorEnvelopeError(
               `500`,
               response,
               errorBody,
-              getErrorMessage2(errorBody, "An internal server error has occurred."),
+              getErrorMessage(errorBody, "An internal server error has occurred."),
               e
             );
           } catch (err) {
@@ -1276,12 +1511,12 @@ var QueryExecutionClient = class {
         case 503: {
           const responseValue = await response.body("json");
           try {
-            const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+            const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
             throw new ErrorEnvelopeError(
               `503`,
               response,
               errorBody,
-              getErrorMessage2(errorBody, "Service is unavailable."),
+              getErrorMessage(errorBody, "Service is unavailable."),
               e
             );
           } catch (err) {
@@ -1302,12 +1537,12 @@ var QueryExecutionClient = class {
           if (response.status >= 400 && response.status <= 499) {
             const responseValue = await response.body("json");
             try {
-              const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+              const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
               throw new ErrorEnvelopeError(
                 `${response.status}`,
                 response,
                 errorBody,
-                getErrorMessage2(errorBody, "Client error."),
+                getErrorMessage(errorBody, "Client error."),
                 e
               );
             } catch (err) {
@@ -1326,12 +1561,12 @@ var QueryExecutionClient = class {
           } else if (response.status >= 500 && response.status <= 599) {
             const responseValue = await response.body("json");
             try {
-              const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+              const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
               throw new ErrorEnvelopeError(
                 `${response.status}`,
                 response,
                 errorBody,
-                getErrorMessage2(errorBody, "Server error."),
+                getErrorMessage(errorBody, "Server error."),
                 e
               );
             } catch (err) {
@@ -1354,7 +1589,7 @@ var QueryExecutionClient = class {
                 `${response.status}`,
                 response,
                 responseValue,
-                getErrorMessage2(
+                getErrorMessage(
                   responseValue,
                   `Unexpected api response: code=${response.status} body="${responseValue}"`
                 )
@@ -1458,7 +1693,7 @@ var QueryExecutionClient = class {
         case 200: {
           const responseValue = await response.body("json");
           try {
-            return this.shouldTransformDates ? transformResponse2(responseValue, [
+            return this.shouldTransformDates ? transformResponse(responseValue, [
               ["result.records.*.start", { datetime: true }],
               ["result.records.*.end", { datetime: true }],
               ["result.records.**.start", { datetime: true }],
@@ -1489,7 +1724,7 @@ var QueryExecutionClient = class {
               `${response.status}`,
               response,
               responseValue,
-              getErrorMessage2(
+              getErrorMessage(
                 responseValue,
                 `Unexpected api response: code=${response.status} body="${responseValue}"`
               )
@@ -1518,17 +1753,17 @@ var QueryExecutionClient = class {
         throw new ApiClientError2("UnexpectedError", "Unexpected error", e);
       }
       const response = e.response;
-      await apiGatewayErrorsHandler2(response);
+      await apiGatewayErrorsHandler(response);
       switch (response.status) {
         case 400: {
           const responseValue = await response.body("json");
           try {
-            const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+            const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
             throw new ErrorEnvelopeError(
               `400`,
               response,
               errorBody,
-              getErrorMessage2(
+              getErrorMessage(
                 errorBody,
                 "The supplied request is wrong. Either the query itself or other parameters are wrong."
               ),
@@ -1550,24 +1785,24 @@ var QueryExecutionClient = class {
         }
         case 410: {
           const contentType = response.headers["content-type"];
-          const encoding = mimeTypeToEncoding(contentType, Encoding.Text);
+          const encoding = mimeTypeToEncoding(contentType, "text" /* Text */);
           const responseValue = await response.body(encoding);
           throw new ClientRequestError3(
             `410`,
             response,
             responseValue,
-            getErrorMessage2(responseValue, `The query for the given request-token is not available anymore.`)
+            getErrorMessage(responseValue, `The query for the given request-token is not available anymore.`)
           );
         }
         case 500: {
           const responseValue = await response.body("json");
           try {
-            const errorBody = this.shouldTransformDates ? transformResponse2(responseValue, []) : responseValue;
+            const errorBody = this.shouldTransformDates ? transformResponse(responseValue, []) : responseValue;
             throw new ErrorEnvelopeError(
               `500`,
               response,
               errorBody,
-              getErrorMessage2(errorBody, "An internal server error has occurred."),
+              getErrorMessage(errorBody, "An internal server error has occurred."),
               e
             );
           } catch (err) {
@@ -1591,7 +1826,7 @@ var QueryExecutionClient = class {
               `${response.status}`,
               response,
               responseValue,
-              getErrorMessage2(
+              getErrorMessage(
                 responseValue,
                 `Unexpected api response: code=${response.status} body="${responseValue}"`
               ),
@@ -1621,7 +1856,7 @@ var queryExecutionClient = /* @__PURE__ */ new QueryExecutionClient(defaultHttpC
 // packages/client/query/src/lib/error-envelopes/index.ts
 import {
   ApiClientError as ApiClientError3,
-  ApiGatewayError,
+  ApiGatewayError as ApiGatewayError2,
   ClientRequestError as ClientRequestError4,
   InvalidResponseError as InvalidResponseError3,
   isApiClientError,
@@ -1734,7 +1969,7 @@ var TokenType = /* @__PURE__ */ ((TokenType2) => {
 })(TokenType || {});
 export {
   ApiClientError3 as ApiClientError,
-  ApiGatewayError,
+  ApiGatewayError2 as ApiGatewayError,
   ClientRequestError4 as ClientRequestError,
   DQLNodeNodeType,
   ErrorEnvelopeError,

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@dynatrace-sdk/client-query",
-  "version": "1.21.1",
+  "version": "1.21.2",
   "description": "Exposes an API to fetch records stored in Grail.",
   "license": "Apache-2.0",
   "dependencies": {
-    "@dynatrace-sdk/http-client": "^1.3.0",
-    "@dynatrace-sdk/shared-client-utils": "^1.0.1",
-    "@dynatrace-sdk/shared-errors": "^1.0.0"
+    "@dynatrace-sdk/http-client": "^1.3.1",
+    "@dynatrace-sdk/shared-errors": "^1.0.2"
   },
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

package/types/packages/{shared-client-utils/src → client/query/src/lib/apis}/api-client-options.d.ts

@@ -1,5 +1,5 @@
 /**
- * Configuration for the API client.
+ * Configuration for generated TypeScript SDK clients
  * @param {boolean} transformDates - Flag to control date transformations, enabled by default.
  */
 export interface ApiClientOptions {

package/types/packages/client/query/src/lib/apis/query-assistance-api.d.ts

@@ -1,11 +1,11 @@
 import { AbortSignal, HttpClient } from '@dynatrace-sdk/http-client';
-import { ApiClientOptions } from '@dynatrace-sdk/shared-client-utils';
 import { AutocompleteRequest } from '../models/autocomplete-request';
 import { AutocompleteResponse } from '../models/autocomplete-response';
 import { DQLNode } from '../models/dql-node';
 import { ParseRequest } from '../models/parse-request';
 import { VerifyRequest } from '../models/verify-request';
 import { VerifyResponse } from '../models/verify-response';
+import { ApiClientOptions } from './api-client-options';
 /**
  * Supporting operations for the Query. Also known as the Language services.
  */

package/types/packages/client/query/src/lib/apis/query-execution-api.d.ts

@@ -1,8 +1,8 @@
 import { AbortSignal, HttpClient } from '@dynatrace-sdk/http-client';
-import { ApiClientOptions } from '@dynatrace-sdk/shared-client-utils';
 import { ExecuteRequest } from '../models/execute-request';
 import { QueryPollResponse } from '../models/query-poll-response';
 import { QueryStartResponse } from '../models/query-start-response';
+import { ApiClientOptions } from './api-client-options';
 /**
  * Operations related to the Query execution.
  */

package/types/packages/client/query/src/lib/error-envelopes/api-gateway-errors-handler.d.ts

@@ -0,0 +1,2 @@
+import { HttpClientResponse } from '@dynatrace-sdk/http-client';
+export declare function apiGatewayErrorsHandler(response: HttpClientResponse): Promise<void>;

package/types/packages/client/query/src/lib/error-envelopes/get-error-message.d.ts

@@ -0,0 +1 @@
+export declare function getErrorMessage(errorBody: unknown, defaultMessage: string): string;