@climatepartner/climatepartner-api-sdk/index.js

The ClimatePartner API provides one uniform public API to customers of ClimatePartner.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __accessCheck = (obj, member, msg) => {
  if (!member.has(obj))
    throw TypeError("Cannot " + msg);
};
var __privateGet = (obj, member, getter) => {
  __accessCheck(obj, member, "read from private field");
  return getter ? getter.call(obj) : member.get(obj);
};
var __privateAdd = (obj, member, value) => {
  if (member.has(obj))
    throw TypeError("Cannot add the same private member more than once");
  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
};
var __privateSet = (obj, member, value, setter) => {
  __accessCheck(obj, member, "write to private field");
  setter ? setter.call(obj, value) : member.set(obj, value);
  return value;
};
var __privateMethod = (obj, member, method) => {
  __accessCheck(obj, member, "access private method");
  return method;
};

// src/gen/function/get-query-params.ts
var EMPTY_STRING, getQueryParameters, getQueryParameter;
var init_get_query_params = __esm({
  "src/gen/function/get-query-params.ts"() {
    EMPTY_STRING = "";
    getQueryParameters = (parameters = []) => {
      const keyValue = [];
      for (const parameter of parameters) {
        if (!!parameter.value) {
          if (Array.isArray(parameter.value)) {
            parameter.value.forEach((v) => keyValue.push(getQueryParameter(parameter.name, v)));
          } else {
            keyValue.push(getQueryParameter(parameter.name, parameter.value));
          }
        }
      }
      if (keyValue.length === 0) {
        return EMPTY_STRING;
      }
      return `?${keyValue.join("&")}`;
    };
    getQueryParameter = (paramName, paramValue) => {
      return `${encodeURIComponent(paramName)}=${encodeURIComponent(paramValue)}`;
    };
  }
});

// src/gen/function/open-api.ts
var DEFAULT_REQUEST_INTERCEPTOR, DEFAULT_RESPONSE_INTERCEPTOR, DEFAULT_ERROR_HANDLER, openApi, buildUrl;
var init_open_api = __esm({
  "src/gen/function/open-api.ts"() {
    DEFAULT_REQUEST_INTERCEPTOR = async (request) => {
      return request;
    };
    DEFAULT_RESPONSE_INTERCEPTOR = async (request, response, retry, error) => {
      return response;
    };
    DEFAULT_ERROR_HANDLER = (error) => {
      return error;
    };
    openApi = {
      requestInterceptor: DEFAULT_REQUEST_INTERCEPTOR,
      responseInterceptor: DEFAULT_RESPONSE_INTERCEPTOR,
      errorHandler: DEFAULT_ERROR_HANDLER,
      endpointUrl: ""
    };
    buildUrl = (url, urlParameter = {}) => {
      let resultUrl = url;
      for (const key of Object.keys(urlParameter)) {
        resultUrl = resultUrl.replace(`{${key}}`, encodeURIComponent(urlParameter[key]));
      }
      return resultUrl;
    };
  }
});

// src/gen/function/fetch-node.ts
var fetch_node_exports = {};
__export(fetch_node_exports, {
  fetch: () => fetch
});
var httpRequest, httpsRequest, fetch;
var init_fetch_node = __esm({
  "src/gen/function/fetch-node.ts"() {
    init_http();
    if (typeof window === "undefined") {
      httpRequest = require("http").request;
      httpsRequest = require("https").request;
    }
    fetch = async (url, { method, headers, body, ...options } = {}) => {
      const _request = typeof url === "string" || url instanceof URL ? new Request(url, { method, headers, body }) : url;
      if (!(_request instanceof Request)) {
        throw new TypeError("url must be string, URL or Request");
      }
      return new Promise((resolve, reject) => {
        const request = _request.url.protocol === "https:" ? httpsRequest : httpRequest;
        const req = request(
          _request.url,
          {
            method: _request.method,
            headers: _request.headers,
            ...options
          },
          (res) => resolve(new Response(res))
        );
        req.on("error", reject);
        req.end(_request.body.length ? _request.body : void 0);
      });
    };
  }
});

// src/gen/function/http.ts
var http, HeadersBase, handler, Headers, Request, Response;
var init_http = __esm({
  "src/gen/function/http.ts"() {
    init_get_query_params();
    init_open_api();
    http = async (request, requestInterceptor, errorHandler, responseInterceptor) => {
      const fetch2 = typeof window !== "undefined" && window.fetch ? window.fetch : (init_fetch_node(), __toCommonJS(fetch_node_exports)).fetch;
      const context = {};
      if (requestInterceptor) {
        request = await requestInterceptor(request, context);
      }
      const run = async (request2) => {
        const queryParams = getQueryParameters(request2.queryParameter);
        const url = `${buildUrl(
          request2.url,
          request2.urlParameter
        )}${queryParams}`;
        try {
          const response = await fetch2(url, {
            method: request2.method,
            headers: request2.header,
            body: request2.body
          });
          if (responseInterceptor) {
            return responseInterceptor(request2, response, run, context);
          } else {
            return response.text();
          }
        } catch (e) {
          return responseInterceptor(request2, void 0, run, context, e);
        }
      };
      return run(request);
    };
    HeadersBase = class {
      constructor(headers) {
      }
    };
    handler = {
      get(target, key) {
        return target[key.toLowerCase()];
      },
      set(target, key, value) {
        if (value === void 0) {
          delete target[key.toLowerCase()];
        } else {
          target[key.toLowerCase()] = value;
        }
        return true;
      },
      deleteProperty(target, key) {
        return delete target[key.toLowerCase()];
      },
      has(target, key) {
        return key.toLowerCase() in target;
      }
    };
    Headers = new Proxy(HeadersBase, {
      construct(target, [headers = {}]) {
        const res = new Proxy(new target(), handler);
        Object.entries(headers).forEach(([key, value]) => {
          res[key] = value;
        });
        return res;
      }
    });
    Request = class {
      constructor(url, { method = "GET", headers = {}, body } = {}) {
        this.url = url instanceof URL ? url : new URL(url);
        this.method = method;
        this.headers = new Headers(headers);
        this.body = Buffer.from(body || "");
      }
    };
    Response = class {
      constructor(incomingMessage) {
        this.incomingMessage = incomingMessage;
        this.status = incomingMessage.statusCode || 0;
        this.statusText = incomingMessage.statusMessage || "";
        this.headers = new Headers(incomingMessage.headers);
        this.body = new Promise((resolve, reject) => {
          const chunks = [];
          incomingMessage.on("data", (chunk) => chunks.push(chunk));
          incomingMessage.on("aborted", () => reject(new Error("aborted")));
          incomingMessage.on("end", () => resolve(Buffer.concat(chunks)));
        });
      }
      async blob() {
        return this.body;
      }
      async text() {
        return (await this.blob()).toString("utf8");
      }
    };
  }
});

// src/index.ts
var src_exports = {};
__export(src_exports, {
  ClimatePartnerApi: () => ClimatePartnerApi,
  UnifiedApi: () => UnifiedApi
});
module.exports = __toCommonJS(src_exports);

// ../../../lib/http-utils/HttpHeaders.ts
var bearerAuthHeader = (token) => `Bearer ${token}`;

// src/gen/service/calculation-base-service.ts
init_http();
init_open_api();
var CalculationBaseService = class {
  constructor() {
    this.airTravel = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/travel/air`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.calculateDistance = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/distance`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.carRentalTravel = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/travel/car-rental`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.ecotransitBatchCalculation = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/logistics/ecotransit/batch`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.ecotransitBatchStatus = async (pathParameter, queryParameter, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const queryParam = [
        { name: "cursor", value: queryParameter.cursor },
        { name: "limit", value: queryParameter.limit }
      ];
      const pathParam = {
        "batchId": pathParameter.batchId
      };
      const response = await http(
        {
          method: "GET",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/logistics/ecotransit/batch/{batchId}`,
          queryParameter: queryParam,
          urlParameter: pathParam,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.ecotransitCalculation = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/logistics/ecotransit`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.getChoiceValues = async (pathParameter, queryParameter, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const queryParam = [
        { name: "cursor", value: queryParameter.cursor },
        { name: "limit", value: queryParameter.limit }
      ];
      const pathParam = {
        "choiceSlug": pathParameter.choiceSlug
      };
      const response = await http(
        {
          method: "GET",
          url: `${openApi.endpointUrl}/calculation/v1/choices/{choiceSlug}`,
          queryParameter: queryParam,
          urlParameter: pathParam,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpAddressableTelevision = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/addressable-television`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpCinema = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/cinema`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpDoohGrossContacts = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/dooh-gross-contacts`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpDoohScreens = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/dooh-screens`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpLinearTelevision = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/linear-television`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpNewspaper = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/newspaper`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpOnlineAudio = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/online-audio`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpOnlineImage = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/online-image`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpOnlineSearch = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/online-search`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpOnlineVideo = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/online-video`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpOOH = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/ooh`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpRadio = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/radio`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpSocialMediaOnlineImage = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/social-media-online-image`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpSocialMediaOnlineVideo = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/social-media-online-video`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpSupplement = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/supplement`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.greenGrpTotalWeight = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/green-grp/print-total-weight`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.hotelStayTravel = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/travel/hotel-stay`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.pppMaterialWeight = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/ppp/weight`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.pppMaterialWeightBatch = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/ppp/weight/batch`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.pppPaperDimension = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/ppp/dimension`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.railTravel = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/travel/rail`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.roadTravel = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/travel/road`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.rothoCalculation = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/pcf-rotho`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.transportTotalEmissions = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/transportTotalEmissions`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.vehicleFleetConsumption = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/vehicle-fleet/consumption`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.vehicleFleetDistance = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/vehicle-fleet/distance`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.wasteManagement = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/calculation/v1/calculate/waste-management`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
  }
};

// src/calculation/index.ts
var CalculationService = class extends CalculationBaseService {
};

// src/index.ts
init_open_api();

// src/gen/service/healthcheck-base-service.ts
init_http();
init_open_api();
var HealthcheckBaseService = class {
  constructor() {
    this.healthcheck = async (interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "GET",
          url: `${openApi.endpointUrl}/healthcheck/v1/healthcheck`,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
  }
};

// src/healthcheck/index.ts
var HealthcheckService = class extends HealthcheckBaseService {
};

// ../../../lib/exponantial-backoff/delay/delayBase.ts
var Delay = class {
  constructor(options) {
    this.options = options;
    this.attempt = 0;
  }
  apply() {
    return new Promise((resolve) => setTimeout(resolve, this.delay));
  }
  setAttemptNumber(attempt) {
    this.attempt = attempt;
  }
  get delay() {
    const constant = this.options.startingDelay;
    const base = this.options.exponantialTime;
    const power = this.numOfDelayedAttempts;
    const delay = constant * Math.pow(base, power);
    return Math.min(delay, this.options.maximumDelay);
  }
  get numOfDelayedAttempts() {
    return this.attempt;
  }
};

// ../../../lib/exponantial-backoff/delay/alwaysDelay/alwaysDelay.ts
var AlwaysDelay = class extends Delay {
};

// ../../../lib/exponantial-backoff/delay/skipFirst/skipFirstDelay.ts
var SkipFirstDelay = class extends Delay {
  async apply() {
    return this.isFirstAttempt ? true : super.apply();
  }
  get isFirstAttempt() {
    return this.attempt === 0;
  }
  get numOfDelayedAttempts() {
    return this.attempt - 1;
  }
};

// ../../../lib/exponantial-backoff/delay/delayFactory.ts
var DelayFactory = (options, attempt) => {
  const delay = initDelayClass(options);
  delay.setAttemptNumber(attempt);
  return delay;
};
var initDelayClass = (options) => {
  if (!options.isFirstAttepmtDelayed) {
    return new SkipFirstDelay(options);
  }
  return new AlwaysDelay(options);
};

// ../../../lib/exponantial-backoff/exponantialBackoff.ts
var ExponantialBackOff = class {
  constructor(request, options) {
    this.request = request;
    this.options = options;
    this.attemptNumber = 0;
  }
  async execute() {
    while (!this.attemptLimitReached) {
      try {
        await this.applyDelay();
        return await this.request();
      } catch (e) {
        this.attemptNumber++;
        const shouldRetry = await this.options.retry(e, this.attemptNumber);
        if (!shouldRetry || this.attemptLimitReached) {
          throw e;
        }
      }
    }
    throw new Error("Something went wrong.");
  }
  get attemptLimitReached() {
    return this.attemptNumber >= this.options.numberOfAttempts;
  }
  async applyDelay() {
    const delay = DelayFactory(this.options, this.attemptNumber);
    await delay.apply();
  }
};

// ../../../lib/exponantial-backoff/interface/types.ts
var defaultOptions = {
  isFirstAttepmtDelayed: false,
  maximumDelay: Infinity,
  numberOfAttempts: 10,
  retry: () => true,
  startingDelay: 100,
  exponantialTime: 2
};
var getOptionsSanitized = (options) => {
  const optionsSanitized = {
    ...defaultOptions,
    ...options
  };
  if (optionsSanitized.numberOfAttempts < 1) {
    optionsSanitized.numberOfAttempts = 1;
  }
  return optionsSanitized;
};

// ../../../lib/exponantial-backoff/index.ts
async function exponantialBackOff(request, options = {}) {
  const sanitizedOptions = getOptionsSanitized(options);
  const backOff = new ExponantialBackOff(request, sanitizedOptions);
  return await backOff.execute();
}

// src/gen/service/order-base-service.ts
init_http();
init_open_api();
var OrderBaseService = class {
  constructor() {
    this.checkOrder = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/order/v1/checkOrder`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.createBatchIndividualOrder = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/order/v1/individualOrdersBatched`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.createCollectiveOrder = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/order/v1/collectiveOrder`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.createIndividualOrder = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/order/v1/individualOrder`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.createSubOrder = async (body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const response = await http(
        {
          method: "POST",
          url: `${openApi.endpointUrl}/order/v1/subOrder`,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.deleteIndividualOrder = async (pathParameter, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const pathParam = {
        "orderId": pathParameter.orderId
      };
      const response = await http(
        {
          method: "DELETE",
          url: `${openApi.endpointUrl}/order/v1/individualOrder/{orderId}`,
          urlParameter: pathParam,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.deleteSubOrder = async (pathParameter, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const pathParam = {
        "orderId": pathParameter.orderId
      };
      const response = await http(
        {
          method: "DELETE",
          url: `${openApi.endpointUrl}/order/v1/subOrder/{orderId}`,
          urlParameter: pathParam,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.getAllOrders = async (queryParameter, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const queryParam = [
        { name: "cursor", value: queryParameter.cursor },
        { name: "limit", value: queryParameter.limit }
      ];
      const response = await http(
        {
          method: "GET",
          url: `${openApi.endpointUrl}/order/v1/allOrder`,
          queryParameter: queryParam,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.getCollectiveOrder = async (pathParameter, queryParameter, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const queryParam = [
        { name: "cursor", value: queryParameter.cursor },
        { name: "limit", value: queryParameter.limit }
      ];
      const pathParam = {
        "collectiveOrderId": pathParameter.collectiveOrderId
      };
      const response = await http(
        {
          method: "GET",
          url: `${openApi.endpointUrl}/order/v1/collectiveOrder/{collectiveOrderId}`,
          queryParameter: queryParam,
          urlParameter: pathParam,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.getIndividualOrder = async (pathParameter, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const pathParam = {
        "orderId": pathParameter.orderId
      };
      const response = await http(
        {
          method: "GET",
          url: `${openApi.endpointUrl}/order/v1/individualOrder/{orderId}`,
          urlParameter: pathParam,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.getSubOrder = async (pathParameter, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const pathParam = {
        "orderId": pathParameter.orderId
      };
      const response = await http(
        {
          method: "GET",
          url: `${openApi.endpointUrl}/order/v1/subOrder/{orderId}`,
          urlParameter: pathParam,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.listProjects = async (pathParameter, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const pathParam = {
        "language": pathParameter.language
      };
      const response = await http(
        {
          method: "GET",
          url: `${openApi.endpointUrl}/order/v1/projects/{language}`,
          urlParameter: pathParam,
          header: {
            Accept: "application/json"
          }
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.updateCollectiveOrder = async (pathParameter, body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const pathParam = {
        "collectiveOrderId": pathParameter.collectiveOrderId
      };
      const response = await http(
        {
          method: "PATCH",
          url: `${openApi.endpointUrl}/order/v1/collectiveOrder/{collectiveOrderId}`,
          urlParameter: pathParam,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.updateIndividualOrder = async (pathParameter, body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const pathParam = {
        "orderId": pathParameter.orderId
      };
      const response = await http(
        {
          method: "PATCH",
          url: `${openApi.endpointUrl}/order/v1/individualOrder/{orderId}`,
          urlParameter: pathParam,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
    this.updateSubOrder = async (pathParameter, body, interceptor = openApi.requestInterceptor, errorHandler = openApi.errorHandler, responseInterceptor = openApi.responseInterceptor) => {
      const pathParam = {
        "orderId": pathParameter.orderId
      };
      const response = await http(
        {
          method: "PATCH",
          url: `${openApi.endpointUrl}/order/v1/subOrder/{orderId}`,
          urlParameter: pathParam,
          header: {
            Accept: "application/json",
            "Content-Type": "application/json"
          },
          body: JSON.stringify(body)
        },
        interceptor,
        errorHandler,
        responseInterceptor
      );
      return JSON.parse(response);
    };
  }
};

// src/types.ts
var UnifiedApiError = class extends Error {
  constructor(statusCode, code, message) {
    super(`[${code}]: ${message}`);
    this.statusCode = statusCode;
    this.code = code;
    this.message = message;
  }
};
var UnifiedApiBadRequestError = class extends UnifiedApiError {
  constructor(statusCode, code, message) {
    super(statusCode, code, message);
    this.statusCode = statusCode;
    this.code = code;
    this.message = message;
  }
};
var UnifiedApiInternalServerError = class extends UnifiedApiError {
  constructor(statusCode, code, message) {
    super(statusCode, code, message);
    this.statusCode = statusCode;
    this.code = code;
    this.message = message;
  }
};

// src/order/index.ts
var allowedStatuses = [
  "CREATE_SUCCESSFUL" /* CREATE_SUCCESSFUL */,
  "CREATE_FAILED" /* CREATE_FAILED */,
  "DELETE_SUCCESSFUL" /* DELETE_SUCCESSFUL */,
  "DELETE_FAILED" /* DELETE_FAILED */,
  "UPDATE_SUCCESSFUL" /* UPDATE_SUCCESSFUL */,
  "UPDATE_FAILED" /* UPDATE_FAILED */
];
var _pollDeletedOrder, pollDeletedOrder_fn, _orderActionSync, orderActionSync_fn;
var OrderService = class extends OrderBaseService {
  constructor() {
    super(...arguments);
    __privateAdd(this, _pollDeletedOrder);
    __privateAdd(this, _orderActionSync);
  }
  async createIndividualOrderSync(body) {
    return __privateMethod(this, _orderActionSync, orderActionSync_fn).call(this, this.createIndividualOrder, [body], (createOrderResponse) => this.getIndividualOrder({
      orderId: createOrderResponse.result.orderId
    }));
  }
  async createCollectiveOrderSync(body) {
    return __privateMethod(this, _orderActionSync, orderActionSync_fn).call(this, this.createCollectiveOrder, [body], (createOrderResponse) => this.getCollectiveOrder(
      {
        collectiveOrderId: createOrderResponse.result.collectiveOrderId
      },
      {}
    ));
  }
  async createSubOrderSync(body) {
    return __privateMethod(this, _orderActionSync, orderActionSync_fn).call(this, this.createSubOrder, [body], (createOrderResponse) => this.getSubOrder({
      orderId: createOrderResponse.result.orderId
    }));
  }
  async updateIndividualOrderSync(pathParameters, body) {
    return __privateMethod(this, _orderActionSync, orderActionSync_fn).call(this, this.updateIndividualOrder, [pathParameters, body], (updateIndividualOrderResponse) => this.getIndividualOrder({
      orderId: updateIndividualOrderResponse.result.orderId
    }));
  }
  async updateCollectiveOrderSync(pathParameters, body) {
    return __privateMethod(this, _orderActionSync, orderActionSync_fn).call(this, this.updateCollectiveOrder, [pathParameters, body], (updateCollectiveOrderResponse) => this.getCollectiveOrder(
      {
        collectiveOrderId: updateCollectiveOrderResponse.result.collectiveOrderId
      },
      {}
    ));
  }
  async updateSubOrderSync(pathParameters, body) {
    return __privateMethod(this, _orderActionSync, orderActionSync_fn).call(this, this.updateSubOrder, [pathParameters, body], (updateSubOrderResponse) => this.getSubOrder({
      orderId: updateSubOrderResponse.result.orderId
    }));
  }
  async deleteIndividualOrderSync(pathParameters) {
    return __privateMethod(this, _orderActionSync, orderActionSync_fn).call(this, this.deleteIndividualOrder, [pathParameters], (deleteIndividualOrderResponse) => __privateMethod(this, _pollDeletedOrder, pollDeletedOrder_fn).call(this, () => this.getIndividualOrder({
      orderId: deleteIndividualOrderResponse.result.orderId
    })));
  }
  async deleteSubOrderSync(pathParameters) {
    return __privateMethod(this, _orderActionSync, orderActionSync_fn).call(this, this.deleteSubOrder, [pathParameters], (deleteSubOrderResponse) => __privateMethod(this, _pollDeletedOrder, pollDeletedOrder_fn).call(this, () => this.getSubOrder({
      orderId: deleteSubOrderResponse.orderId
    })));
  }
};
_pollDeletedOrder = new WeakSet();
pollDeletedOrder_fn = async function(getOrderFunction) {
  try {
    const result = await getOrderFunction();
    if (result.result.lastActionStatus === "DELETE_FAILED" /* DELETE_FAILED */) {
      return result;
    }
  } catch (error) {
    if (error instanceof UnifiedApiError) {
      if (error.code === "ORDER_DELETED" /* ORDER_DELETED */) {
        return {
          result: {
            lastActionStatus: "DELETE_SUCCESSFUL" /* DELETE_SUCCESSFUL */
          }
        };
      }
    }
    throw error;
  }
};
_orderActionSync = new WeakSet();
orderActionSync_fn = async function(orderActionFunction, orderActionArgs, getOrderFunction) {
  try {
    const createOrderResponse = await orderActionFunction.apply(
      this,
      orderActionArgs
    );
    const startingDelay = parseInt(process.env["SDK_ASYNC_DELAY_START" /* SDK_ASYNC_DELAY_START */]) || 100;
    const maximumDelay = parseInt(process.env["SDK_ASYNC_MAX_DELAY" /* SDK_ASYNC_MAX_DELAY */]) || 1e3 * 4;
    const numberOfAttempts = parseInt(process.env["SDK_ASYNC_MAX_ATTEMPTS" /* SDK_ASYNC_MAX_ATTEMPTS */]) || 10;
    const getOrderResponse = await exponantialBackOff(
      async () => {
        const getOrderResponse2 = await getOrderFunction(createOrderResponse);
        if (!getOrderResponse2?.result?.lastActionStatus || !allowedStatuses.includes(
          getOrderResponse2?.result?.lastActionStatus
        )) {
          throw new UnifiedApiError(
            0,
            "REQUEST_TIMED_OUT" /* REQUEST_TIMED_OUT */,
            "Order processing did not finish in time"
          );
        }
        return getOrderResponse2;
      },
      {
        numberOfAttempts,
        startingDelay,
        maximumDelay
      }
    );
    return getOrderResponse;
  } catch (e) {
    if (e instanceof UnifiedApiError) {
      throw e;
    }
    throw new UnifiedApiError(
      0,
      "INTERNAL_ERROR" /* INTERNAL_ERROR */,
      e.message