@dynatrace-sdk/client-query 1.0.0

package/esm/index.js

@@ -0,0 +1,1766 @@
+/**
+ * @license
+ * Copyright 2023 Dynatrace LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// packages/client/query/src/lib/apis/query-assistance-api.ts
+import { httpClient as defaultHttpClient } from "@dynatrace-sdk/http-client";
+
+// packages/platform/shared/utils/get-global-with-dt-runtime.ts
+var getGlobalWithDtRuntime = () => typeof globalThis !== "undefined" ? globalThis : window;
+
+// packages/platform/error-handlers/src/lib/add-global-error-serializer.ts
+function addGlobalErrorSerializer(serializer) {
+  const addGlobalErrorSerializerFunc = getAddGlobalErrorSerializer();
+  if (typeof addGlobalErrorSerializerFunc === "function") {
+    addGlobalErrorSerializerFunc(serializer);
+  } else {
+    console.warn("Missing addGlobalErrorSerializer function from sdk-web-runtime.");
+  }
+}
+function isGlobalErrorSerializerSupported() {
+  return typeof getAddGlobalErrorSerializer() === "function";
+}
+function getAddGlobalErrorSerializer() {
+  return getGlobalWithDtRuntime().dtRuntime?.errorHandlers?.addGlobalErrorSerializer;
+}
+
+// packages/client/query/src/lib/error-envelopes/api-client-error.ts
+var ApiClientError = class extends Error {
+  errorType = "JS Error" /* COMMON */;
+  constructor(name, message) {
+    super(message);
+    this.name = name;
+  }
+};
+function isApiClientError(e) {
+  return e instanceof ApiClientError;
+}
+
+// packages/client/query/src/lib/error-envelopes/client-request-error.ts
+var ClientRequestError = class extends ApiClientError {
+  body;
+  response;
+  constructor(name, response, body, message) {
+    super(name, message);
+    this.errorType = "Http Error" /* HTTP */;
+    this.body = body;
+    this.response = response;
+  }
+};
+function isClientRequestError(e) {
+  return e instanceof ClientRequestError;
+}
+
+// packages/client/query/src/lib/error-envelopes/error-envelope-error.ts
+var ErrorEnvelopeError = class extends ClientRequestError {
+};
+function isErrorEnvelopeError(e) {
+  return e instanceof ErrorEnvelopeError;
+}
+
+// packages/client/query/src/lib/error-envelopes/error-serializer.ts
+var apiClientErrorSerializer = async (error) => {
+  if (isClientRequestError(error)) {
+    const status = error.response.status;
+    const message = error.message;
+    return {
+      name: error.name,
+      status,
+      message,
+      stack: error.stack,
+      type: "Http Error" /* HTTP */
+    };
+  } else if (isApiClientError(error)) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      type: "JS Error" /* COMMON */
+    };
+  }
+};
+var errorSerializerAdded = false;
+function registerGlobalErrorSerializer(serializer) {
+  if (!errorSerializerAdded && isGlobalErrorSerializerSupported()) {
+    errorSerializerAdded = true;
+    addGlobalErrorSerializer(serializer);
+  }
+}
+
+// packages/client/query/src/lib/error-envelopes/invalid-response-error.ts
+var InvalidResponseError = class extends ApiClientError {
+  responseBody;
+  expectedType;
+  nestedError;
+  constructor(name, nestedError, body, expectedType, message) {
+    super(
+      name,
+      message ?? `${name}: Response does not match expected datatype${expectedType ? " " + expectedType : ""}: ${nestedError?.toString() ?? "unable to deserialize"}`
+    );
+    this.nestedError = nestedError;
+    this.responseBody = body;
+    this.expectedType = expectedType;
+  }
+};
+
+// packages/client/query/src/lib/models/autocomplete-request.ts
+var _AutocompleteRequestTransformation;
+((_AutocompleteRequestTransformation2) => {
+  function fromJson(model) {
+    const { query, cursorPosition, timezone, locale } = model;
+    return {
+      query,
+      cursorPosition,
+      timezone,
+      locale
+    };
+  }
+  _AutocompleteRequestTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { query, cursorPosition, timezone, locale } = model;
+    return {
+      query,
+      cursorPosition,
+      timezone,
+      locale
+    };
+  }
+  _AutocompleteRequestTransformation2.toJson = toJson;
+})(_AutocompleteRequestTransformation || (_AutocompleteRequestTransformation = {}));
+
+// packages/client/query/src/lib/models/token-type.ts
+var TokenType = /* @__PURE__ */ ((TokenType4) => {
+  TokenType4["Space"] = "SPACE";
+  TokenType4["Linebreak"] = "LINEBREAK";
+  TokenType4["Indent"] = "INDENT";
+  TokenType4["Pipe"] = "PIPE";
+  TokenType4["Dot"] = "DOT";
+  TokenType4["Colon"] = "COLON";
+  TokenType4["Comma"] = "COMMA";
+  TokenType4["Assignment"] = "ASSIGNMENT";
+  TokenType4["BraceOpen"] = "BRACE_OPEN";
+  TokenType4["BraceClose"] = "BRACE_CLOSE";
+  TokenType4["BracketOpen"] = "BRACKET_OPEN";
+  TokenType4["BracketClose"] = "BRACKET_CLOSE";
+  TokenType4["ParenthesisOpen"] = "PARENTHESIS_OPEN";
+  TokenType4["ParenthesisClose"] = "PARENTHESIS_CLOSE";
+  TokenType4["Quote"] = "QUOTE";
+  TokenType4["SingleQuote"] = "SINGLE_QUOTE";
+  TokenType4["Slash"] = "SLASH";
+  TokenType4["BooleanTrue"] = "BOOLEAN_TRUE";
+  TokenType4["BooleanFalse"] = "BOOLEAN_FALSE";
+  TokenType4["Null"] = "NULL";
+  TokenType4["CommandName"] = "COMMAND_NAME";
+  TokenType4["ParameterKey"] = "PARAMETER_KEY";
+  TokenType4["ParameterValueScope"] = "PARAMETER_VALUE_SCOPE";
+  TokenType4["FunctionName"] = "FUNCTION_NAME";
+  TokenType4["TimeseriesAggregation"] = "TIMESERIES_AGGREGATION";
+  TokenType4["Operator"] = "OPERATOR";
+  TokenType4["TraversalOperator"] = "TRAVERSAL_OPERATOR";
+  TokenType4["TraversalRelationName"] = "TRAVERSAL_RELATION_NAME";
+  TokenType4["TraversalHopCount"] = "TRAVERSAL_HOP_COUNT";
+  TokenType4["SimpleIdentifier"] = "SIMPLE_IDENTIFIER";
+  TokenType4["Number"] = "NUMBER";
+  TokenType4["String"] = "STRING";
+  TokenType4["TimeUnit"] = "TIME_UNIT";
+  TokenType4["TimestampValue"] = "TIMESTAMP_VALUE";
+  TokenType4["MetricKey"] = "METRIC_KEY";
+  TokenType4["Variable"] = "VARIABLE";
+  TokenType4["EndComment"] = "END_COMMENT";
+  return TokenType4;
+})(TokenType || {});
+var _TokenTypeTransformation;
+((_TokenTypeTransformation2) => {
+  _TokenTypeTransformation2.toJson = (value) => value;
+  _TokenTypeTransformation2.fromJson = (value) => value;
+})(_TokenTypeTransformation || (_TokenTypeTransformation = {}));
+
+// packages/client/query/src/lib/models/autocomplete-suggestion-part.ts
+var _AutocompleteSuggestionPartTransformation;
+((_AutocompleteSuggestionPartTransformation2) => {
+  function fromJson(model) {
+    const { type, info, synopsis, suggestion } = model;
+    return {
+      type: _TokenTypeTransformation.fromJson(type),
+      info,
+      synopsis,
+      suggestion
+    };
+  }
+  _AutocompleteSuggestionPartTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { type, info, synopsis, suggestion } = model;
+    return {
+      type: _TokenTypeTransformation.toJson(type),
+      info,
+      synopsis,
+      suggestion
+    };
+  }
+  _AutocompleteSuggestionPartTransformation2.toJson = toJson;
+})(_AutocompleteSuggestionPartTransformation || (_AutocompleteSuggestionPartTransformation = {}));
+
+// packages/client/query/src/lib/models/autocomplete-suggestion.ts
+var _AutocompleteSuggestionTransformation;
+((_AutocompleteSuggestionTransformation2) => {
+  function fromJson(model) {
+    const { parts, alreadyTypedCharacters, suggestion } = model;
+    return {
+      parts: parts?.map((innerValue) => _AutocompleteSuggestionPartTransformation.fromJson(innerValue)),
+      alreadyTypedCharacters,
+      suggestion
+    };
+  }
+  _AutocompleteSuggestionTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { parts, alreadyTypedCharacters, suggestion } = model;
+    return {
+      parts: parts?.map((innerValue) => _AutocompleteSuggestionPartTransformation.toJson(innerValue)),
+      alreadyTypedCharacters,
+      suggestion
+    };
+  }
+  _AutocompleteSuggestionTransformation2.toJson = toJson;
+})(_AutocompleteSuggestionTransformation || (_AutocompleteSuggestionTransformation = {}));
+
+// packages/client/query/src/lib/models/autocomplete-response.ts
+var _AutocompleteResponseTransformation;
+((_AutocompleteResponseTransformation2) => {
+  function fromJson(model) {
+    const { optional, suggestions, suggestedTtlSeconds } = model;
+    return {
+      optional,
+      suggestions: suggestions?.map((innerValue) => _AutocompleteSuggestionTransformation.fromJson(innerValue)),
+      suggestedTtlSeconds
+    };
+  }
+  _AutocompleteResponseTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { optional, suggestions, suggestedTtlSeconds } = model;
+    return {
+      optional,
+      suggestions: suggestions?.map((innerValue) => _AutocompleteSuggestionTransformation.toJson(innerValue)),
+      suggestedTtlSeconds
+    };
+  }
+  _AutocompleteResponseTransformation2.toJson = toJson;
+})(_AutocompleteResponseTransformation || (_AutocompleteResponseTransformation = {}));
+
+// packages/client/query/src/lib/models/dql-alternative-node.ts
+var _DQLAlternativeNodeTransformation;
+((_DQLAlternativeNodeTransformation2) => {
+  function fromJson(model) {
+    const { alternatives } = model;
+    return {
+      ..._DQLNodeTransformation.fromJson(model, false),
+      alternatives
+    };
+  }
+  _DQLAlternativeNodeTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { alternatives } = model;
+    return {
+      ..._DQLNodeTransformation.toJson(model, false),
+      alternatives
+    };
+  }
+  _DQLAlternativeNodeTransformation2.toJson = toJson;
+})(_DQLAlternativeNodeTransformation || (_DQLAlternativeNodeTransformation = {}));
+
+// packages/client/query/src/lib/models/dql-container-node.ts
+var _DQLContainerNodeTransformation;
+((_DQLContainerNodeTransformation2) => {
+  function fromJson(model) {
+    const { type, children } = model;
+    return {
+      ..._DQLNodeTransformation.fromJson(model, false),
+      type,
+      children: children !== void 0 && children !== null ? children?.map((innerValue) => _DQLNodeTransformation.fromJson(innerValue)) : void 0
+    };
+  }
+  _DQLContainerNodeTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { type, children } = model;
+    return {
+      ..._DQLNodeTransformation.toJson(model, false),
+      type,
+      children: children !== void 0 && children !== null ? children?.map((innerValue) => _DQLNodeTransformation.toJson(innerValue)) : void 0
+    };
+  }
+  _DQLContainerNodeTransformation2.toJson = toJson;
+})(_DQLContainerNodeTransformation || (_DQLContainerNodeTransformation = {}));
+
+// packages/client/query/src/lib/models/dql-node-node-type.ts
+var DQLNodeNodeType = /* @__PURE__ */ ((DQLNodeNodeType3) => {
+  DQLNodeNodeType3["Terminal"] = "TERMINAL";
+  DQLNodeNodeType3["Container"] = "CONTAINER";
+  DQLNodeNodeType3["Alternative"] = "ALTERNATIVE";
+  return DQLNodeNodeType3;
+})(DQLNodeNodeType || {});
+var _DQLNodeNodeTypeTransformation;
+((_DQLNodeNodeTypeTransformation2) => {
+  _DQLNodeNodeTypeTransformation2.toJson = (value) => value;
+  _DQLNodeNodeTypeTransformation2.fromJson = (value) => value;
+})(_DQLNodeNodeTypeTransformation || (_DQLNodeNodeTypeTransformation = {}));
+
+// packages/client/query/src/lib/models/dql-terminal-node.ts
+var _DQLTerminalNodeTransformation;
+((_DQLTerminalNodeTransformation2) => {
+  function fromJson(model) {
+    const { type, isMandatoryOnUserOrder, canonicalString } = model;
+    return {
+      ..._DQLNodeTransformation.fromJson(model, false),
+      type: type !== void 0 && type !== null ? _TokenTypeTransformation.fromJson(type) : void 0,
+      isMandatoryOnUserOrder,
+      canonicalString
+    };
+  }
+  _DQLTerminalNodeTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { type, isMandatoryOnUserOrder, canonicalString } = model;
+    return {
+      ..._DQLNodeTransformation.toJson(model, false),
+      type: type !== void 0 && type !== null ? _TokenTypeTransformation.toJson(type) : void 0,
+      isMandatoryOnUserOrder,
+      canonicalString
+    };
+  }
+  _DQLTerminalNodeTransformation2.toJson = toJson;
+})(_DQLTerminalNodeTransformation || (_DQLTerminalNodeTransformation = {}));
+
+// packages/client/query/src/lib/models/position-info.ts
+var _PositionInfoTransformation;
+((_PositionInfoTransformation2) => {
+  function fromJson(model) {
+    const { column, index, line } = model;
+    return {
+      column,
+      index,
+      line
+    };
+  }
+  _PositionInfoTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { column, index, line } = model;
+    return {
+      column,
+      index,
+      line
+    };
+  }
+  _PositionInfoTransformation2.toJson = toJson;
+})(_PositionInfoTransformation || (_PositionInfoTransformation = {}));
+
+// packages/client/query/src/lib/models/token-position.ts
+var _TokenPositionTransformation;
+((_TokenPositionTransformation2) => {
+  function fromJson(model) {
+    const { start, end } = model;
+    return {
+      start: _PositionInfoTransformation.fromJson(start),
+      end: _PositionInfoTransformation.fromJson(end)
+    };
+  }
+  _TokenPositionTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { start, end } = model;
+    return {
+      start: _PositionInfoTransformation.toJson(start),
+      end: _PositionInfoTransformation.toJson(end)
+    };
+  }
+  _TokenPositionTransformation2.toJson = toJson;
+  function fromFormData(formData) {
+    const formDataEntries = Object.fromEntries(formData.map((data) => [data.name, data.value]));
+    return {
+      start: _PositionInfoTransformation.fromJson(JSON.parse(formDataEntries["start"])),
+      end: _PositionInfoTransformation.fromJson(JSON.parse(formDataEntries["end"]))
+    };
+  }
+  _TokenPositionTransformation2.fromFormData = fromFormData;
+  function toFormData(model) {
+    const json = toJson(model);
+    const body = [
+      { name: "start", type: "json", value: json["start"] },
+      { name: "end", type: "json", value: json["end"] }
+    ];
+    return body;
+  }
+  _TokenPositionTransformation2.toFormData = toFormData;
+})(_TokenPositionTransformation || (_TokenPositionTransformation = {}));
+
+// packages/client/query/src/lib/models/dql-node.ts
+var _DQLNodeTransformation;
+((_DQLNodeTransformation2) => {
+  function isDqlTerminalNode(model) {
+    return model["nodeType"] === "TERMINAL";
+  }
+  _DQLNodeTransformation2.isDqlTerminalNode = isDqlTerminalNode;
+  function isDqlContainerNode(model) {
+    return model["nodeType"] === "CONTAINER";
+  }
+  _DQLNodeTransformation2.isDqlContainerNode = isDqlContainerNode;
+  function isDqlAlternativeNode(model) {
+    return model["nodeType"] === "ALTERNATIVE";
+  }
+  _DQLNodeTransformation2.isDqlAlternativeNode = isDqlAlternativeNode;
+  function fromJson(model, includeChildProps = true) {
+    if (includeChildProps) {
+      switch (model.nodeType) {
+        case "TERMINAL":
+          return _DQLTerminalNodeTransformation.fromJson(model);
+        case "CONTAINER":
+          return _DQLContainerNodeTransformation.fromJson(model);
+        case "ALTERNATIVE":
+          return _DQLAlternativeNodeTransformation.fromJson(model);
+        default:
+          return fromJson(model, false);
+      }
+    }
+    const { nodeType, tokenPosition, isOptional } = model;
+    return {
+      nodeType: _DQLNodeNodeTypeTransformation.fromJson(nodeType),
+      tokenPosition: tokenPosition !== void 0 && tokenPosition !== null ? _TokenPositionTransformation.fromJson(tokenPosition) : void 0,
+      isOptional
+    };
+  }
+  _DQLNodeTransformation2.fromJson = fromJson;
+  function toJson(model, includeChildProps = true) {
+    if (includeChildProps) {
+      switch (model.nodeType) {
+        case "TERMINAL":
+          return _DQLTerminalNodeTransformation.toJson(model);
+        case "CONTAINER":
+          return _DQLContainerNodeTransformation.toJson(model);
+        case "ALTERNATIVE":
+          return _DQLAlternativeNodeTransformation.toJson(model);
+        default:
+          return toJson(model, false);
+      }
+    }
+    const { nodeType, tokenPosition, isOptional } = model;
+    return {
+      nodeType: _DQLNodeNodeTypeTransformation.toJson(nodeType),
+      tokenPosition: tokenPosition !== void 0 && tokenPosition !== null ? _TokenPositionTransformation.toJson(tokenPosition) : void 0,
+      isOptional
+    };
+  }
+  _DQLNodeTransformation2.toJson = toJson;
+})(_DQLNodeTransformation || (_DQLNodeTransformation = {}));
+
+// packages/client/query/src/lib/models/error-response-details.ts
+var _ErrorResponseDetailsTransformation;
+((_ErrorResponseDetailsTransformation2) => {
+  function fromJson(model) {
+    const {
+      exceptionType,
+      syntaxErrorPosition,
+      errorType,
+      errorMessage,
+      arguments: _arguments,
+      queryString,
+      errorMessageFormatSpecifierTypes,
+      errorMessageFormat
+    } = model;
+    return {
+      exceptionType,
+      syntaxErrorPosition: syntaxErrorPosition !== void 0 && syntaxErrorPosition !== null ? _TokenPositionTransformation.fromJson(syntaxErrorPosition) : void 0,
+      errorType,
+      errorMessage,
+      arguments: _arguments?.slice(0),
+      queryString,
+      errorMessageFormatSpecifierTypes: errorMessageFormatSpecifierTypes?.slice(0),
+      errorMessageFormat
+    };
+  }
+  _ErrorResponseDetailsTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const {
+      exceptionType,
+      syntaxErrorPosition,
+      errorType,
+      errorMessage,
+      arguments: _arguments,
+      queryString,
+      errorMessageFormatSpecifierTypes,
+      errorMessageFormat
+    } = model;
+    return {
+      exceptionType,
+      syntaxErrorPosition: syntaxErrorPosition !== void 0 && syntaxErrorPosition !== null ? _TokenPositionTransformation.toJson(syntaxErrorPosition) : void 0,
+      errorType,
+      errorMessage,
+      arguments: _arguments?.slice(0),
+      queryString,
+      errorMessageFormatSpecifierTypes: errorMessageFormatSpecifierTypes?.slice(0),
+      errorMessageFormat
+    };
+  }
+  _ErrorResponseDetailsTransformation2.toJson = toJson;
+})(_ErrorResponseDetailsTransformation || (_ErrorResponseDetailsTransformation = {}));
+
+// packages/client/query/src/lib/models/error-response.ts
+var _ErrorResponseTransformation;
+((_ErrorResponseTransformation2) => {
+  function fromJson(model) {
+    const { message, details, code } = model;
+    return {
+      message,
+      details: _ErrorResponseDetailsTransformation.fromJson(details),
+      code
+    };
+  }
+  _ErrorResponseTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { message, details, code } = model;
+    return {
+      message,
+      details: _ErrorResponseDetailsTransformation.toJson(details),
+      code
+    };
+  }
+  _ErrorResponseTransformation2.toJson = toJson;
+})(_ErrorResponseTransformation || (_ErrorResponseTransformation = {}));
+
+// packages/client/query/src/lib/models/error-envelope.ts
+var _ErrorEnvelopeTransformation;
+((_ErrorEnvelopeTransformation2) => {
+  function fromJson(model) {
+    const { error } = model;
+    return {
+      error: _ErrorResponseTransformation.fromJson(error)
+    };
+  }
+  _ErrorEnvelopeTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { error } = model;
+    return {
+      error: _ErrorResponseTransformation.toJson(error)
+    };
+  }
+  _ErrorEnvelopeTransformation2.toJson = toJson;
+  function fromFormData(formData) {
+    const formDataEntries = Object.fromEntries(formData.map((data) => [data.name, data.value]));
+    return {
+      error: _ErrorResponseTransformation.fromJson(JSON.parse(formDataEntries["error"]))
+    };
+  }
+  _ErrorEnvelopeTransformation2.fromFormData = fromFormData;
+  function toFormData(model) {
+    const json = toJson(model);
+    const body = [{ name: "error", type: "json", value: json["error"] }];
+    return body;
+  }
+  _ErrorEnvelopeTransformation2.toFormData = toFormData;
+})(_ErrorEnvelopeTransformation || (_ErrorEnvelopeTransformation = {}));
+
+// packages/client/query/src/lib/models/parse-request.ts
+var _ParseRequestTransformation;
+((_ParseRequestTransformation2) => {
+  function fromJson(model) {
+    const { query, timezone, locale } = model;
+    return {
+      query,
+      timezone,
+      locale
+    };
+  }
+  _ParseRequestTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { query, timezone, locale } = model;
+    return {
+      query,
+      timezone,
+      locale
+    };
+  }
+  _ParseRequestTransformation2.toJson = toJson;
+})(_ParseRequestTransformation || (_ParseRequestTransformation = {}));
+
+// packages/client/query/src/lib/models/verify-request.ts
+var _VerifyRequestTransformation;
+((_VerifyRequestTransformation2) => {
+  function fromJson(model) {
+    const { query, timezone, locale } = model;
+    return {
+      query,
+      timezone,
+      locale
+    };
+  }
+  _VerifyRequestTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { query, timezone, locale } = model;
+    return {
+      query,
+      timezone,
+      locale
+    };
+  }
+  _VerifyRequestTransformation2.toJson = toJson;
+})(_VerifyRequestTransformation || (_VerifyRequestTransformation = {}));
+
+// packages/client/query/src/lib/models/metadata-notification.ts
+var _MetadataNotificationTransformation;
+((_MetadataNotificationTransformation2) => {
+  function fromJson(model) {
+    const {
+      severity,
+      messageFormat,
+      syntaxPosition,
+      messageFormatSpecifierTypes,
+      arguments: _arguments,
+      notificationType,
+      message
+    } = model;
+    return {
+      severity,
+      messageFormat,
+      syntaxPosition: syntaxPosition !== void 0 && syntaxPosition !== null ? _TokenPositionTransformation.fromJson(syntaxPosition) : void 0,
+      messageFormatSpecifierTypes: messageFormatSpecifierTypes !== void 0 && messageFormatSpecifierTypes !== null ? messageFormatSpecifierTypes?.slice(0) : void 0,
+      arguments: _arguments !== void 0 && _arguments !== null ? _arguments?.slice(0) : void 0,
+      notificationType,
+      message
+    };
+  }
+  _MetadataNotificationTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const {
+      severity,
+      messageFormat,
+      syntaxPosition,
+      messageFormatSpecifierTypes,
+      arguments: _arguments,
+      notificationType,
+      message
+    } = model;
+    return {
+      severity,
+      messageFormat,
+      syntaxPosition: syntaxPosition !== void 0 && syntaxPosition !== null ? _TokenPositionTransformation.toJson(syntaxPosition) : void 0,
+      messageFormatSpecifierTypes: messageFormatSpecifierTypes !== void 0 && messageFormatSpecifierTypes !== null ? messageFormatSpecifierTypes?.slice(0) : void 0,
+      arguments: _arguments !== void 0 && _arguments !== null ? _arguments?.slice(0) : void 0,
+      notificationType,
+      message
+    };
+  }
+  _MetadataNotificationTransformation2.toJson = toJson;
+})(_MetadataNotificationTransformation || (_MetadataNotificationTransformation = {}));
+
+// packages/client/query/src/lib/models/verify-response.ts
+var _VerifyResponseTransformation;
+((_VerifyResponseTransformation2) => {
+  function fromJson(model) {
+    const { valid, notifications } = model;
+    return {
+      valid,
+      notifications: notifications !== void 0 && notifications !== null ? notifications?.map((innerValue) => _MetadataNotificationTransformation.fromJson(innerValue)) : void 0
+    };
+  }
+  _VerifyResponseTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { valid, notifications } = model;
+    return {
+      valid,
+      notifications: notifications !== void 0 && notifications !== null ? notifications?.map((innerValue) => _MetadataNotificationTransformation.toJson(innerValue)) : void 0
+    };
+  }
+  _VerifyResponseTransformation2.toJson = toJson;
+})(_VerifyResponseTransformation || (_VerifyResponseTransformation = {}));
+
+// packages/client/query/src/lib/apis/query-assistance-api.ts
+var QueryAssistanceClient = class {
+  httpClient;
+  constructor(httpClientImplementation) {
+    this.httpClient = httpClientImplementation;
+    registerGlobalErrorSerializer(apiClientErrorSerializer);
+  }
+  async queryVerify(config) {
+    if (!config) {
+      throw new ApiClientError("API client error", "API client call is missing mandatory config parameter");
+    }
+    const encodedBody = _VerifyRequestTransformation.toJson(config.body);
+    const headerParameters = {
+      ...config.authorization !== void 0 && { Authorization: String(config.authorization) }
+    };
+    const response = await this.httpClient.send({
+      url: `/platform/storage/query/v1/query:verify`,
+      method: "POST",
+      requestBodyType: "json",
+      body: encodedBody,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...headerParameters
+      },
+      abortSignal: config.abortSignal,
+      statusValidator: (status) => {
+        if (200 <= status && status < 300) {
+          return true;
+        }
+        return [400, 500].includes(status);
+      }
+    });
+    switch (response.status) {
+      case 400: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError("400", response, errorBody, "The supplied request is wrong.");
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryAssistanceClient.query:verify:400`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 500: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError("500", response, errorBody, "An internal server error has occurred.");
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryAssistanceClient.query:verify:500`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 200: {
+        const responseValue = await response.body("json");
+        try {
+          return _VerifyResponseTransformation.fromJson(responseValue);
+        } catch (err) {
+          throw new InvalidResponseError(
+            `QueryAssistanceClient.query:verify:${response.status}`,
+            err,
+            responseValue,
+            void 0,
+            void 0
+          );
+        }
+      }
+      default: {
+        const responseValue = await response.body("text").catch();
+        throw new ClientRequestError(
+          `${response.status}`,
+          response,
+          responseValue,
+          `Unexpected api response: code=${response.status} body="${responseValue}"`
+        );
+      }
+    }
+  }
+  async queryParse(config) {
+    if (!config) {
+      throw new ApiClientError("API client error", "API client call is missing mandatory config parameter");
+    }
+    const encodedBody = _ParseRequestTransformation.toJson(config.body);
+    const headerParameters = {
+      ...config.authorization !== void 0 && { Authorization: String(config.authorization) }
+    };
+    const response = await this.httpClient.send({
+      url: `/platform/storage/query/v1/query:parse`,
+      method: "POST",
+      requestBodyType: "json",
+      body: encodedBody,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...headerParameters
+      },
+      abortSignal: config.abortSignal,
+      statusValidator: (status) => {
+        if (200 <= status && status < 300) {
+          return true;
+        }
+        return [400, 500].includes(status);
+      }
+    });
+    switch (response.status) {
+      case 400: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError(
+            "400",
+            response,
+            errorBody,
+            "The supplied request is wrong. Either the query itself or other parameters are wrong."
+          );
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryAssistanceClient.query:parse:400`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 500: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError("500", response, errorBody, "An internal server error has occurred.");
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryAssistanceClient.query:parse:500`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 200: {
+        const responseValue = await response.body("json");
+        try {
+          return _DQLNodeTransformation.fromJson(responseValue);
+        } catch (err) {
+          throw new InvalidResponseError(
+            `QueryAssistanceClient.query:parse:${response.status}`,
+            err,
+            responseValue,
+            void 0,
+            void 0
+          );
+        }
+      }
+      default: {
+        const responseValue = await response.body("text").catch();
+        throw new ClientRequestError(
+          `${response.status}`,
+          response,
+          responseValue,
+          `Unexpected api response: code=${response.status} body="${responseValue}"`
+        );
+      }
+    }
+  }
+  async queryAutocomplete(config) {
+    if (!config) {
+      throw new ApiClientError("API client error", "API client call is missing mandatory config parameter");
+    }
+    const encodedBody = _AutocompleteRequestTransformation.toJson(config.body);
+    const headerParameters = {
+      ...config.authorization !== void 0 && { Authorization: String(config.authorization) }
+    };
+    const response = await this.httpClient.send({
+      url: `/platform/storage/query/v1/query:autocomplete`,
+      method: "POST",
+      requestBodyType: "json",
+      body: encodedBody,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...headerParameters
+      },
+      abortSignal: config.abortSignal,
+      statusValidator: (status) => {
+        if (200 <= status && status < 300) {
+          return true;
+        }
+        return [400, 500].includes(status);
+      }
+    });
+    switch (response.status) {
+      case 400: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError(
+            "400",
+            response,
+            errorBody,
+            "The supplied request is wrong. Either the query itself or other parameters are wrong."
+          );
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryAssistanceClient.query:autocomplete:400`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 500: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError("500", response, errorBody, "An internal server error has occurred.");
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryAssistanceClient.query:autocomplete:500`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 200: {
+        const responseValue = await response.body("json");
+        try {
+          return _AutocompleteResponseTransformation.fromJson(responseValue);
+        } catch (err) {
+          throw new InvalidResponseError(
+            `QueryAssistanceClient.query:autocomplete:${response.status}`,
+            err,
+            responseValue,
+            void 0,
+            void 0
+          );
+        }
+      }
+      default: {
+        const responseValue = await response.body("text").catch();
+        throw new ClientRequestError(
+          `${response.status}`,
+          response,
+          responseValue,
+          `Unexpected api response: code=${response.status} body="${responseValue}"`
+        );
+      }
+    }
+  }
+};
+var queryAssistanceClient = /* @__PURE__ */ new QueryAssistanceClient(defaultHttpClient);
+
+// packages/client/query/src/lib/apis/query-execution-api.ts
+import { httpClient as defaultHttpClient2 } from "@dynatrace-sdk/http-client";
+
+// packages/client/query/src/lib/models/execute-request.ts
+var _ExecuteRequestTransformation;
+((_ExecuteRequestTransformation2) => {
+  function fromJson(model) {
+    const {
+      query,
+      defaultTimeframeStart,
+      defaultTimeframeEnd,
+      timezone,
+      locale,
+      maxResultRecords,
+      fetchTimeoutSeconds,
+      requestTimeoutMilliseconds,
+      enablePreview,
+      defaultSamplingRatio,
+      defaultScanLimitGbytes
+    } = model;
+    return {
+      query,
+      defaultTimeframeStart,
+      defaultTimeframeEnd,
+      timezone,
+      locale,
+      maxResultRecords,
+      fetchTimeoutSeconds,
+      requestTimeoutMilliseconds,
+      enablePreview,
+      defaultSamplingRatio,
+      defaultScanLimitGbytes
+    };
+  }
+  _ExecuteRequestTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const {
+      query,
+      defaultTimeframeStart,
+      defaultTimeframeEnd,
+      timezone,
+      locale,
+      maxResultRecords,
+      fetchTimeoutSeconds,
+      requestTimeoutMilliseconds,
+      enablePreview,
+      defaultSamplingRatio,
+      defaultScanLimitGbytes
+    } = model;
+    return {
+      query,
+      defaultTimeframeStart,
+      defaultTimeframeEnd,
+      timezone,
+      locale,
+      maxResultRecords,
+      fetchTimeoutSeconds,
+      requestTimeoutMilliseconds,
+      enablePreview,
+      defaultSamplingRatio,
+      defaultScanLimitGbytes
+    };
+  }
+  _ExecuteRequestTransformation2.toJson = toJson;
+})(_ExecuteRequestTransformation || (_ExecuteRequestTransformation = {}));
+
+// packages/client/query/src/lib/models/timeframe.ts
+var _TimeframeTransformation;
+((_TimeframeTransformation2) => {
+  function fromJson(model) {
+    const { start, end } = model;
+    return {
+      start: start !== void 0 && start !== null ? new Date(start) : void 0,
+      end: end !== void 0 && end !== null ? new Date(end) : void 0
+    };
+  }
+  _TimeframeTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { start, end } = model;
+    return {
+      start: start !== void 0 && start !== null ? start.toISOString() : void 0,
+      end: end !== void 0 && end !== null ? end.toISOString() : void 0
+    };
+  }
+  _TimeframeTransformation2.toJson = toJson;
+})(_TimeframeTransformation || (_TimeframeTransformation = {}));
+
+// packages/client/query/src/lib/models/grail-metadata.ts
+var _GrailMetadataTransformation;
+((_GrailMetadataTransformation2) => {
+  function fromJson(model) {
+    const {
+      canonicalQuery,
+      timezone,
+      query,
+      scannedRecords,
+      dqlVersion,
+      scannedBytes,
+      analysisTimeframe,
+      locale,
+      executionTimeMilliseconds,
+      notifications,
+      queryId
+    } = model;
+    return {
+      canonicalQuery,
+      timezone,
+      query,
+      scannedRecords,
+      dqlVersion,
+      scannedBytes,
+      analysisTimeframe: analysisTimeframe !== void 0 && analysisTimeframe !== null ? _TimeframeTransformation.fromJson(analysisTimeframe) : void 0,
+      locale,
+      executionTimeMilliseconds,
+      notifications: notifications !== void 0 && notifications !== null ? notifications?.map((innerValue) => _MetadataNotificationTransformation.fromJson(innerValue)) : void 0,
+      queryId
+    };
+  }
+  _GrailMetadataTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const {
+      canonicalQuery,
+      timezone,
+      query,
+      scannedRecords,
+      dqlVersion,
+      scannedBytes,
+      analysisTimeframe,
+      locale,
+      executionTimeMilliseconds,
+      notifications,
+      queryId
+    } = model;
+    return {
+      canonicalQuery,
+      timezone,
+      query,
+      scannedRecords,
+      dqlVersion,
+      scannedBytes,
+      analysisTimeframe: analysisTimeframe !== void 0 && analysisTimeframe !== null ? _TimeframeTransformation.toJson(analysisTimeframe) : void 0,
+      locale,
+      executionTimeMilliseconds,
+      notifications: notifications !== void 0 && notifications !== null ? notifications?.map((innerValue) => _MetadataNotificationTransformation.toJson(innerValue)) : void 0,
+      queryId
+    };
+  }
+  _GrailMetadataTransformation2.toJson = toJson;
+})(_GrailMetadataTransformation || (_GrailMetadataTransformation = {}));
+
+// packages/client/query/src/lib/models/metric-metadata.ts
+var _MetricMetadataTransformation;
+((_MetricMetadataTransformation2) => {
+  function fromJson(model) {
+    const { "metric.key": metricKey, displayName, description, unit } = model;
+    return {
+      "metric.key": metricKey,
+      displayName,
+      description,
+      unit
+    };
+  }
+  _MetricMetadataTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { "metric.key": metricKey, displayName, description, unit } = model;
+    return {
+      "metric.key": metricKey,
+      displayName,
+      description,
+      unit
+    };
+  }
+  _MetricMetadataTransformation2.toJson = toJson;
+})(_MetricMetadataTransformation || (_MetricMetadataTransformation = {}));
+
+// packages/client/query/src/lib/models/metadata.ts
+var _MetadataTransformation;
+((_MetadataTransformation2) => {
+  function fromJson(model) {
+    const { grail, metrics } = model;
+    return {
+      grail: grail !== void 0 && grail !== null ? _GrailMetadataTransformation.fromJson(grail) : void 0,
+      metrics: metrics !== void 0 && metrics !== null ? metrics?.map((innerValue) => _MetricMetadataTransformation.fromJson(innerValue)) : void 0
+    };
+  }
+  _MetadataTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { grail, metrics } = model;
+    return {
+      grail: grail !== void 0 && grail !== null ? _GrailMetadataTransformation.toJson(grail) : void 0,
+      metrics: metrics !== void 0 && metrics !== null ? metrics?.map((innerValue) => _MetricMetadataTransformation.toJson(innerValue)) : void 0
+    };
+  }
+  _MetadataTransformation2.toJson = toJson;
+})(_MetadataTransformation || (_MetadataTransformation = {}));
+
+// packages/client/query/src/lib/models/field-type-type.ts
+var FieldTypeType = /* @__PURE__ */ ((FieldTypeType3) => {
+  FieldTypeType3["Boolean"] = "boolean";
+  FieldTypeType3["String"] = "string";
+  FieldTypeType3["Double"] = "double";
+  FieldTypeType3["Long"] = "long";
+  FieldTypeType3["Timestamp"] = "timestamp";
+  FieldTypeType3["Timeframe"] = "timeframe";
+  FieldTypeType3["Duration"] = "duration";
+  FieldTypeType3["Binary"] = "binary";
+  FieldTypeType3["IpAddress"] = "ip_address";
+  FieldTypeType3["GeoPoint"] = "geo_point";
+  FieldTypeType3["Array"] = "array";
+  FieldTypeType3["Record"] = "record";
+  FieldTypeType3["Undefined"] = "undefined";
+  return FieldTypeType3;
+})(FieldTypeType || {});
+var _FieldTypeTypeTransformation;
+((_FieldTypeTypeTransformation2) => {
+  _FieldTypeTypeTransformation2.toJson = (value) => value;
+  _FieldTypeTypeTransformation2.fromJson = (value) => value;
+})(_FieldTypeTypeTransformation || (_FieldTypeTypeTransformation = {}));
+
+// packages/client/query/src/lib/models/field-type.ts
+var _FieldTypeTransformation;
+((_FieldTypeTransformation2) => {
+  function fromJson(model) {
+    const { type, types } = model;
+    return {
+      type: _FieldTypeTypeTransformation.fromJson(type),
+      types: types !== void 0 && types !== null ? types?.map((innerValue) => _RangedFieldTypesTransformation.fromJson(innerValue)) : void 0
+    };
+  }
+  _FieldTypeTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { type, types } = model;
+    return {
+      type: _FieldTypeTypeTransformation.toJson(type),
+      types: types !== void 0 && types !== null ? types?.map((innerValue) => _RangedFieldTypesTransformation.toJson(innerValue)) : void 0
+    };
+  }
+  _FieldTypeTransformation2.toJson = toJson;
+})(_FieldTypeTransformation || (_FieldTypeTransformation = {}));
+
+// packages/client/query/src/lib/models/ranged-field-types-mappings.ts
+var _RangedFieldTypesMappingsTransformation;
+((_RangedFieldTypesMappingsTransformation2) => {
+  function fromJson(model) {
+    const additionalProps = model;
+    return {
+      ...Object.fromEntries(
+        Object.entries(additionalProps).map(([propName, value]) => [
+          propName,
+          value !== void 0 && value !== null ? _FieldTypeTransformation.fromJson(value) : void 0
+        ])
+      )
+    };
+  }
+  _RangedFieldTypesMappingsTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const additionalProps = model;
+    return {
+      ...Object.fromEntries(
+        Object.entries(additionalProps).map(([propName, value]) => [
+          propName,
+          value !== void 0 && value !== null ? _FieldTypeTransformation.toJson(value) : void 0
+        ])
+      )
+    };
+  }
+  _RangedFieldTypesMappingsTransformation2.toJson = toJson;
+})(_RangedFieldTypesMappingsTransformation || (_RangedFieldTypesMappingsTransformation = {}));
+
+// packages/client/query/src/lib/models/ranged-field-types.ts
+var _RangedFieldTypesTransformation;
+((_RangedFieldTypesTransformation2) => {
+  function fromJson(model) {
+    const { mappings, indexRange } = model;
+    return {
+      mappings: _RangedFieldTypesMappingsTransformation.fromJson(mappings),
+      indexRange: indexRange !== void 0 && indexRange !== null ? indexRange?.slice(0) : void 0
+    };
+  }
+  _RangedFieldTypesTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { mappings, indexRange } = model;
+    return {
+      mappings: _RangedFieldTypesMappingsTransformation.toJson(mappings),
+      indexRange: indexRange !== void 0 && indexRange !== null ? indexRange?.slice(0) : void 0
+    };
+  }
+  _RangedFieldTypesTransformation2.toJson = toJson;
+})(_RangedFieldTypesTransformation || (_RangedFieldTypesTransformation = {}));
+
+// packages/client/query/src/lib/models/result-record-value.ts
+var _ResultRecordValueTransformation;
+((_ResultRecordValueTransformation2) => {
+  function fromJson(model) {
+    return model;
+  }
+  _ResultRecordValueTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    return model;
+  }
+  _ResultRecordValueTransformation2.toJson = toJson;
+})(_ResultRecordValueTransformation || (_ResultRecordValueTransformation = {}));
+
+// packages/client/query/src/lib/models/result-record.ts
+var _ResultRecordTransformation;
+((_ResultRecordTransformation2) => {
+  function fromJson(model) {
+    if (model === null) {
+      return null;
+    }
+    const additionalProps = model;
+    return {
+      ...Object.fromEntries(
+        Object.entries(additionalProps).map(([propName, value]) => [
+          propName,
+          value !== void 0 && value !== null ? _ResultRecordValueTransformation.fromJson(value) : void 0
+        ])
+      )
+    };
+  }
+  _ResultRecordTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    if (model === null) {
+      return null;
+    }
+    const additionalProps = model;
+    return {
+      ...Object.fromEntries(
+        Object.entries(additionalProps).map(([propName, value]) => [
+          propName,
+          value !== void 0 && value !== null ? _ResultRecordValueTransformation.toJson(value) : void 0
+        ])
+      )
+    };
+  }
+  _ResultRecordTransformation2.toJson = toJson;
+})(_ResultRecordTransformation || (_ResultRecordTransformation = {}));
+
+// packages/client/query/src/lib/models/query-result.ts
+var _QueryResultTransformation;
+((_QueryResultTransformation2) => {
+  function fromJson(model) {
+    const { records, metadata, types } = model;
+    return {
+      records: records?.map((innerValue) => _ResultRecordTransformation.fromJson(innerValue)),
+      metadata: _MetadataTransformation.fromJson(metadata),
+      types: types?.map((innerValue) => _RangedFieldTypesTransformation.fromJson(innerValue))
+    };
+  }
+  _QueryResultTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { records, metadata, types } = model;
+    return {
+      records: records?.map((innerValue) => _ResultRecordTransformation.toJson(innerValue)),
+      metadata: _MetadataTransformation.toJson(metadata),
+      types: types?.map((innerValue) => _RangedFieldTypesTransformation.toJson(innerValue))
+    };
+  }
+  _QueryResultTransformation2.toJson = toJson;
+})(_QueryResultTransformation || (_QueryResultTransformation = {}));
+
+// packages/client/query/src/lib/models/query-state.ts
+var QueryState = /* @__PURE__ */ ((QueryState4) => {
+  QueryState4["NotStarted"] = "NOT_STARTED";
+  QueryState4["Running"] = "RUNNING";
+  QueryState4["Succeeded"] = "SUCCEEDED";
+  QueryState4["ResultGone"] = "RESULT_GONE";
+  QueryState4["Cancelled"] = "CANCELLED";
+  QueryState4["Failed"] = "FAILED";
+  return QueryState4;
+})(QueryState || {});
+var _QueryStateTransformation;
+((_QueryStateTransformation2) => {
+  _QueryStateTransformation2.toJson = (value) => value;
+  _QueryStateTransformation2.fromJson = (value) => value;
+})(_QueryStateTransformation || (_QueryStateTransformation = {}));
+
+// packages/client/query/src/lib/models/query-poll-response.ts
+var _QueryPollResponseTransformation;
+((_QueryPollResponseTransformation2) => {
+  function fromJson(model) {
+    const { result, ttlSeconds, progress, state } = model;
+    return {
+      result: result !== void 0 && result !== null ? _QueryResultTransformation.fromJson(result) : void 0,
+      ttlSeconds,
+      progress,
+      state: _QueryStateTransformation.fromJson(state)
+    };
+  }
+  _QueryPollResponseTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { result, ttlSeconds, progress, state } = model;
+    return {
+      result: result !== void 0 && result !== null ? _QueryResultTransformation.toJson(result) : void 0,
+      ttlSeconds,
+      progress,
+      state: _QueryStateTransformation.toJson(state)
+    };
+  }
+  _QueryPollResponseTransformation2.toJson = toJson;
+})(_QueryPollResponseTransformation || (_QueryPollResponseTransformation = {}));
+
+// packages/client/query/src/lib/models/query-start-response.ts
+var _QueryStartResponseTransformation;
+((_QueryStartResponseTransformation2) => {
+  function fromJson(model) {
+    const { result, ttlSeconds, progress, requestToken, state } = model;
+    return {
+      result: result !== void 0 && result !== null ? _QueryResultTransformation.fromJson(result) : void 0,
+      ttlSeconds,
+      progress,
+      requestToken,
+      state: _QueryStateTransformation.fromJson(state)
+    };
+  }
+  _QueryStartResponseTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { result, ttlSeconds, progress, requestToken, state } = model;
+    return {
+      result: result !== void 0 && result !== null ? _QueryResultTransformation.toJson(result) : void 0,
+      ttlSeconds,
+      progress,
+      requestToken,
+      state: _QueryStateTransformation.toJson(state)
+    };
+  }
+  _QueryStartResponseTransformation2.toJson = toJson;
+})(_QueryStartResponseTransformation || (_QueryStartResponseTransformation = {}));
+
+// 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 addArrayQueryParam = (query, key) => {
+  const arrayValue = query[key];
+  return arrayValue.map((value) => encodeQueryParam(key, value)).join("&");
+};
+var addQueryParam = (query, key) => encodeQueryParam(key, query[key]);
+var toQueryString = (rawQuery) => {
+  const query = rawQuery || {};
+  const keys = Object.keys(query).filter((key) => typeof query[key] !== "undefined");
+  return keys.map((key) => Array.isArray(query[key]) ? addArrayQueryParam(query, key) : addQueryParam(query, key)).join("&");
+};
+
+// packages/client/query/src/lib/apis/query-execution-api.ts
+var QueryExecutionClient = class {
+  httpClient;
+  constructor(httpClientImplementation) {
+    this.httpClient = httpClientImplementation;
+    registerGlobalErrorSerializer(apiClientErrorSerializer);
+  }
+  async queryPoll(config) {
+    if (!config) {
+      throw new ApiClientError("API client error", "API client call is missing mandatory config parameter");
+    }
+    const query = toQueryString({
+      "request-token": config.requestToken,
+      "request-timeout-milliseconds": config.requestTimeoutMilliseconds,
+      enrich: config.enrich
+    });
+    const response = await this.httpClient.send({
+      url: `/platform/storage/query/v1/query:poll?${query}`,
+      method: "GET",
+      headers: {
+        Accept: "application/json"
+      },
+      abortSignal: config.abortSignal,
+      statusValidator: (status) => {
+        if (200 <= status && status < 300) {
+          return true;
+        }
+        return [410, 500].includes(status);
+      }
+    });
+    switch (response.status) {
+      case 410: {
+        const responseValue = await response.body("text");
+        throw new ClientRequestError(
+          `410`,
+          response,
+          responseValue,
+          `The query for the given request-token is not available anymore.`
+        );
+      }
+      case 500: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError("500", response, errorBody, "An internal server error has occurred.");
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryExecutionClient.query:poll:500`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 200: {
+        const responseValue = await response.body("json");
+        try {
+          return _QueryPollResponseTransformation.fromJson(responseValue);
+        } catch (err) {
+          throw new InvalidResponseError(
+            `QueryExecutionClient.query:poll:${response.status}`,
+            err,
+            responseValue,
+            void 0,
+            void 0
+          );
+        }
+      }
+      default: {
+        const responseValue = await response.body("text").catch();
+        throw new ClientRequestError(
+          `${response.status}`,
+          response,
+          responseValue,
+          `Unexpected api response: code=${response.status} body="${responseValue}"`
+        );
+      }
+    }
+  }
+  async queryExecute(config) {
+    if (!config) {
+      throw new ApiClientError("API client error", "API client call is missing mandatory config parameter");
+    }
+    const encodedBody = _ExecuteRequestTransformation.toJson(config.body);
+    const query = toQueryString({ enrich: config.enrich });
+    const headerParameters = {
+      ...config.authorization !== void 0 && { Authorization: String(config.authorization) }
+    };
+    const response = await this.httpClient.send({
+      url: `/platform/storage/query/v1/query:execute?${query}`,
+      method: "POST",
+      requestBodyType: "json",
+      body: encodedBody,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...headerParameters
+      },
+      abortSignal: config.abortSignal,
+      statusValidator: (status) => {
+        if (200 <= status && status < 300) {
+          return true;
+        }
+        return [400, 500, 503].includes(status);
+      }
+    });
+    switch (response.status) {
+      case 400: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError(
+            "400",
+            response,
+            errorBody,
+            "The supplied request is wrong. Either the query itself or other parameters are wrong."
+          );
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryExecutionClient.query:execute:400`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 500: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError("500", response, errorBody, "An internal server error has occurred.");
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryExecutionClient.query:execute:500`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 503: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError("503", response, errorBody, "Service is unavailable.");
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryExecutionClient.query:execute:503`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 200: {
+        const responseValue = await response.body("json");
+        try {
+          return _QueryStartResponseTransformation.fromJson(responseValue);
+        } catch (err) {
+          throw new InvalidResponseError(
+            `QueryExecutionClient.query:execute:${response.status}`,
+            err,
+            responseValue,
+            void 0,
+            void 0
+          );
+        }
+      }
+      case 202: {
+        const responseValue = await response.body("json");
+        try {
+          return _QueryStartResponseTransformation.fromJson(responseValue);
+        } catch (err) {
+          throw new InvalidResponseError(
+            `QueryExecutionClient.query:execute:${response.status}`,
+            err,
+            responseValue,
+            void 0,
+            void 0
+          );
+        }
+      }
+      default: {
+        const responseValue = await response.body("text").catch();
+        throw new ClientRequestError(
+          `${response.status}`,
+          response,
+          responseValue,
+          `Unexpected api response: code=${response.status} body="${responseValue}"`
+        );
+      }
+    }
+  }
+  async queryCancel(config) {
+    if (!config) {
+      throw new ApiClientError("API client error", "API client call is missing mandatory config parameter");
+    }
+    const query = toQueryString({ "request-token": config.requestToken });
+    const response = await this.httpClient.send({
+      url: `/platform/storage/query/v1/query:cancel?${query}`,
+      method: "POST",
+      headers: {
+        Accept: "application/json"
+      },
+      abortSignal: config.abortSignal,
+      statusValidator: (status) => {
+        if (200 <= status && status < 300) {
+          return true;
+        }
+        return [410, 500].includes(status);
+      }
+    });
+    switch (response.status) {
+      case 410: {
+        const responseValue = await response.body("text");
+        throw new ClientRequestError(
+          `410`,
+          response,
+          responseValue,
+          `The query for the given request-token is not available anymore.`
+        );
+      }
+      case 500: {
+        const responseValue = await response.body("json");
+        try {
+          const errorBody = _ErrorEnvelopeTransformation.fromJson(responseValue);
+          throw new ErrorEnvelopeError("500", response, errorBody, "An internal server error has occurred.");
+        } catch (err) {
+          if (err instanceof ErrorEnvelopeError) {
+            throw err;
+          }
+          throw new InvalidResponseError(
+            `QueryExecutionClient.query:cancel:500`,
+            err,
+            responseValue,
+            "ErrorEnvelope",
+            void 0
+          );
+        }
+      }
+      case 200: {
+        const responseValue = await response.body("json");
+        try {
+          return _QueryPollResponseTransformation.fromJson(responseValue);
+        } catch (err) {
+          throw new InvalidResponseError(
+            `QueryExecutionClient.query:cancel:${response.status}`,
+            err,
+            responseValue,
+            void 0,
+            void 0
+          );
+        }
+      }
+      case 202: {
+        return;
+      }
+      default: {
+        const responseValue = await response.body("text").catch();
+        throw new ClientRequestError(
+          `${response.status}`,
+          response,
+          responseValue,
+          `Unexpected api response: code=${response.status} body="${responseValue}"`
+        );
+      }
+    }
+  }
+};
+var queryExecutionClient = /* @__PURE__ */ new QueryExecutionClient(defaultHttpClient2);
+
+// packages/client/query/src/lib/models/geo-point.ts
+var _GeoPointTransformation;
+((_GeoPointTransformation2) => {
+  function fromJson(model) {
+    const { latitude, longitude } = model;
+    return {
+      latitude,
+      longitude
+    };
+  }
+  _GeoPointTransformation2.fromJson = fromJson;
+  function toJson(model) {
+    const { latitude, longitude } = model;
+    return {
+      latitude,
+      longitude
+    };
+  }
+  _GeoPointTransformation2.toJson = toJson;
+})(_GeoPointTransformation || (_GeoPointTransformation = {}));
+export {
+  DQLNodeNodeType,
+  FieldTypeType,
+  QueryAssistanceClient,
+  QueryExecutionClient,
+  QueryState,
+  TokenType,
+  _AutocompleteRequestTransformation,
+  _AutocompleteResponseTransformation,
+  _AutocompleteSuggestionPartTransformation,
+  _AutocompleteSuggestionTransformation,
+  _DQLAlternativeNodeTransformation,
+  _DQLContainerNodeTransformation,
+  _DQLNodeNodeTypeTransformation,
+  _DQLNodeTransformation,
+  _DQLTerminalNodeTransformation,
+  _ErrorEnvelopeTransformation,
+  _ErrorResponseDetailsTransformation,
+  _ErrorResponseTransformation,
+  _ExecuteRequestTransformation,
+  _FieldTypeTransformation,
+  _FieldTypeTypeTransformation,
+  _GeoPointTransformation,
+  _GrailMetadataTransformation,
+  _MetadataNotificationTransformation,
+  _MetadataTransformation,
+  _MetricMetadataTransformation,
+  _ParseRequestTransformation,
+  _PositionInfoTransformation,
+  _QueryPollResponseTransformation,
+  _QueryResultTransformation,
+  _QueryStartResponseTransformation,
+  _QueryStateTransformation,
+  _RangedFieldTypesMappingsTransformation,
+  _RangedFieldTypesTransformation,
+  _ResultRecordTransformation,
+  _ResultRecordValueTransformation,
+  _TimeframeTransformation,
+  _TokenPositionTransformation,
+  _TokenTypeTransformation,
+  _VerifyRequestTransformation,
+  _VerifyResponseTransformation,
+  isApiClientError,
+  isClientRequestError,
+  isErrorEnvelopeError,
+  queryAssistanceClient,
+  queryExecutionClient
+};