@juhuu/sdk-ts 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -0,0 +1,989 @@
+// src/index.service.ts
+import io from "socket.io-client";
+var Service = class {
+  constructor(config) {
+    this.environment = config.environment;
+    this.getAccessToken = config.getAccessToken;
+    this.onException = config.onException;
+    this.setAccessToken = config.setAccessToken;
+    this.getAccessToken = config.getAccessToken;
+    this.setRefreshToken = config.setRefreshToken;
+    this.getRefreshToken = config.getRefreshToken;
+    this.clientVersion = config.clientVersion;
+    switch (config.environment) {
+      case "development":
+        this.httpBaseUrl = "https://api.juhuu.dev/v1/";
+        this.wssBaseUrl = "wss://api.juhuu.dev/v1/";
+        break;
+      default:
+        this.httpBaseUrl = "https://api.juhuu.app/v1/";
+        this.wssBaseUrl = "wss://api.juhuu.app/v1/";
+        break;
+    }
+  }
+  environment;
+  httpBaseUrl;
+  wssBaseUrl;
+  clientVersion;
+  onException;
+  getAccessToken;
+  setAccessToken;
+  getRefreshToken;
+  setRefreshToken;
+  async sendRequest({
+    url,
+    method,
+    body = void 0,
+    useAuthentication
+  }, options = {}) {
+    if (options.triggerOnException === void 0) {
+      options.triggerOnException = true;
+    }
+    if (options.refreshTokensIfNecessary === void 0) {
+      options.refreshTokensIfNecessary = true;
+    }
+    let token = null;
+    if (useAuthentication === true && options.accessToken === void 0) {
+      token = await this.getAccessToken();
+      if (token === null) {
+        console.error(
+          "endpoint",
+          url,
+          "should use authentication but no token was found"
+        );
+        return {
+          ok: false,
+          data: null
+        };
+      }
+    } else if (useAuthentication === true && options.accessToken !== void 0) {
+      token = options.accessToken;
+    }
+    const uri = this.httpBaseUrl + url;
+    let response = null;
+    let responseObject = null;
+    try {
+      switch (method) {
+        case "GET": {
+          response = await this.sendGetRequest(token, uri);
+          break;
+        }
+        case "POST": {
+          response = await this.sendPostRequest(token, uri, body);
+          break;
+        }
+        case "PATCH": {
+          response = await this.sendPatchRequest(token, uri, body);
+          break;
+        }
+      }
+      if (response.ok === false) {
+        throw new Error(response.statusText);
+      }
+      responseObject = {
+        ok: response.ok,
+        data: await response.json(),
+        statusText: response.statusText,
+        status: response.status
+      };
+    } catch (error) {
+      console.error(error);
+      responseObject = {
+        ok: false,
+        data: await response?.json(),
+        statusText: response?.statusText ?? "no statusText",
+        status: response?.status ?? 0
+      };
+      if (responseObject.status === 403 && options.refreshTokensIfNecessary === true) {
+        console.log("refreshing tokens...");
+        const oldRefreshToken = await this.getRefreshToken();
+        console.log("old refresh token", oldRefreshToken);
+        if (oldRefreshToken === null) {
+          console.log("no old refresh token found");
+          return responseObject;
+        }
+        console.log("sending request to refresh tokens...");
+        const query = await this.sendRequest(
+          {
+            method: "GET",
+            url: "auth/refresh",
+            body: void 0,
+            useAuthentication: true
+          },
+          {
+            accessToken: oldRefreshToken,
+            // use old refresh token instead of access token
+            triggerOnException: false,
+            refreshTokensIfNecessary: false
+          }
+        );
+        console.log("query for new tokens", query);
+        if (query.ok === false) {
+          return responseObject;
+        }
+        const accessToken = query.data.accessToken;
+        const refreshToken = query.data.refreshToken;
+        await Promise.all([
+          this.setRefreshToken(refreshToken),
+          this.setAccessToken(accessToken)
+        ]);
+        console.log("retrying original request...");
+        const retryResponse = await this.sendRequest(
+          {
+            url,
+            method,
+            body,
+            useAuthentication
+          },
+          {
+            accessToken,
+            refreshTokensIfNecessary: false
+          }
+        );
+        console.log("retry response", retryResponse);
+        if (retryResponse.ok === true) {
+          return retryResponse;
+        } else {
+          return responseObject;
+        }
+      }
+      if (options.triggerOnException === true) {
+        await this.onException(responseObject);
+      }
+    } finally {
+      console.log(
+        method + ": " + uri + " (body: " + JSON.stringify(body, null, 2) + ") => " + JSON.stringify(responseObject, null, 2)
+      );
+    }
+    return responseObject;
+  }
+  async sendGetRequest(token, uri) {
+    return await fetch(uri, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Version": this.clientVersion,
+        Authorization: token ? `Bearer ${token}` : ""
+      }
+    });
+  }
+  async sendPostRequest(token, uri, body) {
+    return await fetch(uri, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Version": this.clientVersion,
+        Authorization: token ? `Bearer ${token}` : ""
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  async sendPatchRequest(token, uri, body) {
+    return await fetch(uri, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Version": this.clientVersion,
+        Authorization: token ? `Bearer ${token}` : ""
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  connectToWebsocket({ url }) {
+    const uri = this.wssBaseUrl + url;
+    console.log("connecting to websocket", uri);
+    const socket = io(uri, { transports: ["websocket"] });
+    socket.on("connect", () => {
+      console.log("connected to websocket", uri);
+    });
+    socket.on("connect_error", (error) => {
+      console.error("Connection error:", error);
+    });
+    return socket;
+  }
+  disconnectFromWebsocket(socket) {
+    socket.disconnect();
+  }
+};
+
+// src/sessions/sessions.service.ts
+var SessionService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async create(SessionCreateParams, SessionCreateOptions) {
+    return await super.sendRequest({
+      method: "POST",
+      url: "sessions",
+      body: {
+        locationId: SessionCreateParams.locationId,
+        tariffId: SessionCreateParams.tariffId,
+        autoRenew: SessionCreateParams.autoRenew,
+        type: SessionCreateParams.sessionType,
+        isOffSession: SessionCreateParams.isOffSession,
+        idempotencyKey: SessionCreateParams.idempotencyKey,
+        userId: SessionCreateParams.userId
+      },
+      useAuthentication: true
+    });
+  }
+  async retrieve(SessionRetrieveParams, SessionRetrieveOptions) {
+    const queryArray = [];
+    if (SessionRetrieveOptions?.expand !== void 0) {
+      queryArray.push("expand=" + SessionRetrieveOptions.expand.join(","));
+    }
+    return await super.sendRequest({
+      method: "GET",
+      url: "sessions/" + SessionRetrieveParams.sessionId + "?" + queryArray.join("&"),
+      body: void 0,
+      useAuthentication: true
+    });
+  }
+  async list(SessionListParams, SessionListOptions) {
+    const queryArray = [];
+    if (SessionListParams.userId !== void 0) {
+      queryArray.push("userId=" + SessionListParams.userId);
+    }
+    if (SessionListParams.propertyId !== void 0) {
+      queryArray.push("propertyId=" + SessionListParams.propertyId);
+    }
+    if (SessionListParams.statusArray !== void 0) {
+      queryArray.push("statusArray=" + SessionListParams.statusArray.join(","));
+    }
+    if (SessionListParams.managementUserId !== void 0) {
+      queryArray.push("managementUserId=" + SessionListParams.managementUserId);
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "sessions?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: true
+      },
+      SessionListOptions
+    );
+  }
+  async update(SessionUpdateParams, SessionUpdateOptions) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "sessions/" + SessionUpdateParams.sessionId,
+        body: {
+          autoRenew: SessionUpdateParams?.autoRenew
+        },
+        useAuthentication: true
+      },
+      SessionUpdateOptions
+    );
+  }
+  async terminate(SessionTerminateParams, SessionTerminateOptions) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "sessions/" + SessionTerminateParams.sessionId + "/terminate",
+        body: {
+          isOffSession: SessionTerminateParams.isOffSession
+        },
+        useAuthentication: true
+      },
+      SessionTerminateOptions
+    );
+  }
+  async attachLocation(SessionTerminateParams, SessionTerminateOptions) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "sessions/" + SessionTerminateParams.sessionId + "/attachLocation",
+        body: {
+          locationId: SessionTerminateParams.locationId
+        },
+        useAuthentication: true
+      },
+      SessionTerminateOptions
+    );
+  }
+};
+
+// src/links/links.service.ts
+var LinkService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async create() {
+  }
+  async retrieve(LinkRetrieveParams, LinkRetrieveOptions) {
+    const queryArray = [];
+    return await super.sendRequest({
+      method: "GET",
+      url: "links/" + LinkRetrieveParams.linkId + "?" + queryArray.join("&"),
+      body: void 0,
+      useAuthentication: false
+    });
+  }
+  async list(LinkListParams, LinkListOptions) {
+    const queryArray = [];
+    if (LinkListParams.propertyId !== void 0) {
+      queryArray.push("propertyId=" + LinkListParams.propertyId);
+    }
+    if (LinkListParams.fiveLetterQr !== void 0) {
+      queryArray.push("fiveLetterQr=" + LinkListParams.fiveLetterQr);
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "links?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: true
+      },
+      LinkListOptions
+    );
+  }
+  async update() {
+  }
+  async delete() {
+  }
+  async terminate() {
+  }
+};
+
+// src/users/users.service.ts
+var UsersService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async create() {
+  }
+  async retrieve(UserRetrieveParams, UserRetrieveOptions) {
+    const queryArray = [];
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "users/" + UserRetrieveParams.userId + "?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: true
+      },
+      UserRetrieveOptions
+    );
+  }
+  async exists(UserExistsParams, UserExistsOptions) {
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "users/exists?email=" + UserExistsParams.email,
+        body: void 0,
+        useAuthentication: false
+      },
+      UserExistsOptions
+    );
+  }
+  async registerEmailPassword(UserRegisterEmailPasswordParams, UserRegisterEmailPasswordOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "auth/emailPassword/register",
+        body: {
+          email: UserRegisterEmailPasswordParams.email,
+          password: UserRegisterEmailPasswordParams.password
+        },
+        useAuthentication: false
+      },
+      UserRegisterEmailPasswordOptions
+    );
+  }
+  async loginEmailPassword(UserLoginEmailPasswordParams, UserLoginEmailPasswordOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "auth/emailPassword/login",
+        body: {
+          email: UserLoginEmailPasswordParams.email,
+          password: UserLoginEmailPasswordParams.password
+        },
+        useAuthentication: false
+      },
+      UserLoginEmailPasswordOptions
+    );
+  }
+  async paymentMethodTokens(UserPaymentMethodTokensParams, UserPaymentMethodTokensOptions) {
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "users/" + UserPaymentMethodTokensParams.userId + "/paymentMethodTokens",
+        body: void 0,
+        useAuthentication: true
+      },
+      UserPaymentMethodTokensOptions
+    );
+  }
+  async refreshAccessToken(UserRefreshAccessTokenParams, UserRefreshAccessTokenOptions) {
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "auth/refresh",
+        body: void 0,
+        useAuthentication: true
+      },
+      {
+        accessToken: UserRefreshAccessTokenParams?.refreshToken,
+        ...UserRefreshAccessTokenOptions
+      }
+    );
+  }
+  async list(UserListParams, UserListOptions) {
+    const queryArray = [];
+    if (UserListParams.managementUserId !== void 0) {
+      queryArray.push("managementUserId=" + UserListParams.managementUserId);
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "users?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: true
+      },
+      UserListOptions
+    );
+  }
+  async update(UserUpdateParams, UserUpdateOptions) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "users/" + UserUpdateParams.userId,
+        body: {
+          name: UserUpdateParams?.name,
+          licenseArray: UserUpdateParams?.licenseArray,
+          platform: UserUpdateParams?.platform,
+          languageCode: UserUpdateParams?.languageCode,
+          appVersion: UserUpdateParams?.appVersion,
+          billingAddress: UserUpdateParams?.billingAddress,
+          vat: UserUpdateParams?.vat,
+          acceptedTermIdArray: UserUpdateParams?.acceptedTermIdArray
+        },
+        useAuthentication: true
+      },
+      UserUpdateOptions
+    );
+  }
+  async inviteEmployee(UserInviteEmployeeParams, UserInviteEmployeeOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "users/" + UserInviteEmployeeParams.userId + "/inviteEmployee",
+        body: {
+          userId: UserInviteEmployeeParams?.userIdToInvite,
+          email: UserInviteEmployeeParams?.email
+        },
+        useAuthentication: true
+      },
+      UserInviteEmployeeOptions
+    );
+  }
+  async removeEmployee(UserRemoveEmployeeParams, UserRemoveEmployeeOptions) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "users/" + UserRemoveEmployeeParams.userId + "/removeEmployee",
+        body: {
+          userId: UserRemoveEmployeeParams.userIdToRemove
+        },
+        useAuthentication: true
+      },
+      UserRemoveEmployeeOptions
+    );
+  }
+};
+
+// src/payments/payments.service.ts
+var PaymentsService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async create() {
+  }
+  async retrieve(PaymentRetrieveParams, PaymentRetrieveOptions) {
+    const queryArray = [];
+    if (PaymentRetrieveOptions?.expand !== void 0) {
+      queryArray.push("expand=" + PaymentRetrieveOptions.expand.join(","));
+    }
+    return await super.sendRequest({
+      method: "GET",
+      url: "payments/" + PaymentRetrieveParams.paymentId + "?" + queryArray.join("&"),
+      body: void 0,
+      useAuthentication: true
+    });
+  }
+  async tokens(PaymentTokensParams, PaymentTokensOptions) {
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "payments/" + PaymentTokensParams.paymentId + "/tokens",
+        body: void 0,
+        useAuthentication: true
+      },
+      PaymentTokensOptions
+    );
+  }
+  async update() {
+  }
+  async delete() {
+  }
+  async retrieveInvoiceUrl(PaymentRetrieveInvoiceUrlParams, PaymentRetrieveInvoiceUrlOptions) {
+    const queryArray = [];
+    return await super.sendRequest({
+      method: "GET",
+      url: "payments/" + PaymentRetrieveInvoiceUrlParams.paymentId + "/invoiceUrl",
+      body: void 0,
+      useAuthentication: true
+    });
+  }
+};
+
+// src/properties/properties.service.ts
+var PropertiesService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async create() {
+  }
+  async retrieve(PropertyRetrieveParams, PropertyRetrieveOptions) {
+    const queryArray = [];
+    return await super.sendRequest({
+      method: "GET",
+      url: "properties/" + PropertyRetrieveParams.propertyId + "?" + queryArray.join("&"),
+      body: void 0,
+      useAuthentication: false
+    });
+  }
+  async list(PropertyListParams, PropertyListOptions) {
+    const queryArray = [];
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "properties?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: false
+      },
+      PropertyListOptions
+    );
+  }
+  async update() {
+  }
+  async delete() {
+  }
+  async terminate() {
+  }
+};
+
+// src/points/points.service.ts
+var PointsService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async map(PointListParams, PointListOptions) {
+    const queryArray = [
+      "modalityArray=" + PointListParams.modalityArray.join(","),
+      "categoryArray=" + PointListParams.categoryArray.join(","),
+      "sectorArray=" + PointListParams.sectorArray.join(","),
+      "longitudeTopLeft=" + PointListParams.longitudeTopLeft,
+      "latitudeTopLeft=" + PointListParams.latitudeTopLeft,
+      "longitudeBottomRight=" + PointListParams.longitudeBottomRight,
+      "latitudeBottomRight=" + PointListParams.latitudeBottomRight
+    ];
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "points/map?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: false
+      },
+      PointListOptions
+    );
+  }
+  toRadians(degrees) {
+    return degrees * Math.PI / 180;
+  }
+  calculateDistance(lat1, lon1, lat2, lon2) {
+    var R = 6371e3;
+    var \u03C61 = this.toRadians(lat1);
+    var \u03C62 = this.toRadians(lat2);
+    var \u0394\u03C6 = this.toRadians(lat2 - lat1);
+    var \u0394\u03BB = this.toRadians(lon2 - lon1);
+    var a = Math.sin(\u0394\u03C6 / 2) * Math.sin(\u0394\u03C6 / 2) + Math.cos(\u03C61) * Math.cos(\u03C62) * Math.sin(\u0394\u03BB / 2) * Math.sin(\u0394\u03BB / 2);
+    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return R * c;
+  }
+  calculateAltitudeForTopDownView(topLeftLat, topLeftLon, bottomRightLat, bottomRightLon) {
+    var diagonalDistance = this.calculateDistance(
+      topLeftLat,
+      topLeftLon,
+      bottomRightLat,
+      bottomRightLon
+    );
+    const diagonalDistanceHalf = Math.round(diagonalDistance / 2);
+    if (diagonalDistanceHalf < 0) {
+      return 0;
+    }
+    if (diagonalDistanceHalf > 1e6) {
+      return 1e6;
+    }
+    return diagonalDistanceHalf;
+  }
+};
+
+// src/devices/devices.service.ts
+var DevicesService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async create() {
+  }
+  async retrieve(DeviceRetrieveParams, DeviceRetrieveOptions) {
+    const queryArray = [];
+    if (DeviceRetrieveParams?.source !== void 0) {
+      queryArray.push("source=" + DeviceRetrieveParams.source);
+    }
+    if (DeviceRetrieveOptions?.expand !== void 0) {
+      queryArray.push("expand=" + DeviceRetrieveOptions.expand.join(","));
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "devices/" + DeviceRetrieveParams.deviceId + "?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: false
+      },
+      DeviceRetrieveOptions
+    );
+  }
+  async list(DeviceListParams, DeviceListOptions) {
+    const queryArray = [];
+    if (DeviceListParams?.statusArray !== void 0) {
+      queryArray.push("statusArray=" + DeviceListParams.statusArray.join(","));
+    }
+    if (DeviceListParams?.rentable !== void 0) {
+      queryArray.push("rentable=" + DeviceListParams.rentable);
+    }
+    if (DeviceListParams?.propertyId !== void 0) {
+      queryArray.push("propertyId=" + DeviceListParams.propertyId);
+    }
+    if (DeviceListParams?.visible !== void 0) {
+      queryArray.push("visible=" + DeviceListParams.visible);
+    }
+    if (DeviceListParams?.deviceTemplateId !== void 0) {
+      queryArray.push("deviceTemplateId=" + DeviceListParams.deviceTemplateId);
+    }
+    if (DeviceListParams?.termId !== void 0) {
+      queryArray.push("termId=" + DeviceListParams.termId);
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "devices?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: false
+      },
+      DeviceListOptions
+    );
+  }
+  async update() {
+  }
+  async delete() {
+  }
+  listen(DeviceRealtimeParams, DeviceRealtimeOptions) {
+    const socket = super.connectToWebsocket({
+      url: "devices/" + DeviceRealtimeParams.deviceId + "/websocket"
+    });
+    const onUpdated = (onUpdatedCallback) => {
+      socket.on("updated", (message) => {
+        onUpdatedCallback(message);
+      });
+    };
+    return {
+      onUpdated,
+      close: () => {
+        console.log("closing websocket connection");
+        socket.close();
+      }
+    };
+  }
+  async message(DeviceMessageParams, DeviceMessageOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "devices?" + DeviceMessageParams.deviceId + "/message",
+        body: {
+          message: DeviceMessageParams.message
+        },
+        useAuthentication: true
+      },
+      DeviceMessageOptions
+    );
+  }
+  async parameterUpdate(DeviceParameterParams, DeviceParameterOptions) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "devices/" + DeviceParameterParams.deviceId + "/parameter/" + DeviceParameterParams.parameterName,
+        body: {
+          value: DeviceParameterParams.value
+        },
+        useAuthentication: true
+      },
+      DeviceParameterOptions
+    );
+  }
+  async commandExecute(DeviceCommandExecuteParams, DeviceCommandExecuteOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "devices/" + DeviceCommandExecuteParams.deviceId + "/command/" + DeviceCommandExecuteParams.commandName,
+        body: {},
+        useAuthentication: true
+      },
+      DeviceCommandExecuteOptions
+    );
+  }
+};
+
+// src/deviceTemplates/deviceTemplates.service.ts
+var DeviceTemplatesService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async create() {
+  }
+  async retrieve(DeviceTemplateRetrieveParams, DeviceTemplateRetrieveOptions) {
+    const queryArray = [];
+    if (DeviceTemplateRetrieveParams?.source !== void 0) {
+      queryArray.push("source=" + DeviceTemplateRetrieveParams.source);
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "deviceTemplates/" + DeviceTemplateRetrieveParams.deviceTemplateId + "?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: false
+      },
+      DeviceTemplateRetrieveOptions
+    );
+  }
+  async update() {
+  }
+  async delete() {
+  }
+  async terminate() {
+  }
+};
+
+// src/locations/locations.service.ts
+var LocationsService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async retrieve(LocationRetrieveParams, LocationRetrieveOptions) {
+    const queryArray = [];
+    if (LocationRetrieveOptions?.expand !== void 0) {
+      queryArray.push("expand=" + LocationRetrieveOptions.expand.join(","));
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "locations/" + LocationRetrieveParams.locationId + "?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: false
+      },
+      LocationRetrieveOptions
+    );
+  }
+  async list(LocationListParams, LocationListOptions) {
+    const queryArray = [];
+    if (LocationListParams?.rentableDeviceGroupLocationId !== void 0) {
+      queryArray.push(
+        "rentableDeviceGroupLocationId=" + LocationListParams.rentableDeviceGroupLocationId
+      );
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "locations?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: false
+      },
+      LocationListOptions
+    );
+  }
+};
+
+// src/terms/terms.service.ts
+var TermsService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async retrieve(TermRetrieveParams, TermRetrieveOptions) {
+    const queryArray = [];
+    if (TermRetrieveOptions?.expand !== void 0) {
+      queryArray.push("expand=" + TermRetrieveOptions.expand.join(","));
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "terms/" + TermRetrieveParams.termId + "?" + queryArray.join("&"),
+        body: void 0,
+        useAuthentication: false
+      },
+      TermRetrieveOptions
+    );
+  }
+  async accept(TermAcceptParams, TermAcceptOptions) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "terms/" + TermAcceptParams.termId + "/accept",
+        body: {
+          userId: TermAcceptParams.userId
+        },
+        useAuthentication: true
+      },
+      TermAcceptOptions
+    );
+  }
+};
+
+// src/tariffs/tariffs.service.ts
+var TariffsService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async create() {
+  }
+  // async retrieve(
+  //     TariffRetrieveParams: JUHUU.Tariff.Retrieve.Params,
+  //     TariffRetrieveOptions?: JUHUU.Tariff.Retrieve.Options,
+  // ): Promise<JUHUU.HttpResponse<JUHUU.Tariff.Retrieve.Response>> {
+  //     const queryArray: string[] = [];
+  //     return await super.sendRequest<JUHUU.Tariff.Retrieve.Response>({
+  //         method: "GET",
+  //         url:
+  //             "tariffs/" +
+  //             TariffRetrieveParams.propertyId +
+  //             "?" +
+  //             queryArray.join("&"),
+  //         body: undefined,
+  //         useAuthentication: false,
+  //     });
+  // }
+  // async list(
+  //     TariffListParams: JUHUU.Tariff.List.Params,
+  //     TariffListOptions?: JUHUU.Tariff.List.Options,
+  // ): Promise<JUHUU.HttpResponse<JUHUU.Tariff.List.Response>> {
+  //     const queryArray: string[] = [];
+  //     return await super.sendRequest<JUHUU.Tariff.List.Response>(
+  //         {
+  //             method: "GET",
+  //             url: "tariffs?" + queryArray.join("&"),
+  //             body: undefined,
+  //             useAuthentication: false,
+  //         },
+  //         TariffListOptions,
+  //     );
+  // }
+  async update() {
+  }
+  async delete() {
+  }
+  async terminate() {
+  }
+  /**
+   * Checks if the tariff is free
+   */
+  isFree(tariff) {
+    if (tariff.amount.every((amount) => amount === 0) === true && tariff.continue === 0) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Returns the amount of seconds the tariff needs to be active before the amount will not change anymore
+   */
+  getAmountFinalizationDuration(tariff) {
+    if (this.isFree(tariff) === true) {
+      return 0;
+    }
+    if (tariff.interval === 0) {
+      return 0;
+    }
+    if (tariff.continue === 0) {
+      return tariff.interval * tariff.amount.length;
+    } else {
+      return tariff.duration;
+    }
+  }
+  /**
+   * Calculates the amount for a give rent time in seconds
+   */
+  calculateAmount(tariff, rentTimeSeconds) {
+    if (this.isFree(tariff) === true) {
+      return 0;
+    }
+    if (tariff.interval === 0) {
+      return tariff.amount[0];
+    }
+    if (rentTimeSeconds > tariff.duration) {
+      console.warn("rentTimeS is greater than duration");
+      rentTimeSeconds = tariff.duration;
+    }
+    let sum = 0;
+    const startedIntervals = Math.ceil(rentTimeSeconds / tariff.interval);
+    for (let i = 0; i < startedIntervals; i += 1) {
+      if (i < tariff.amount.length) {
+        sum += tariff.amount[i];
+      } else {
+        sum += tariff.continue;
+      }
+    }
+    let serviceFee = sum * tariff.serviceFeePercentage / 100;
+    if (serviceFee < tariff.serviceFeeMin) {
+      serviceFee = tariff.serviceFeeMin;
+    } else if (serviceFee > tariff.serviceFeeMax) {
+      serviceFee = tariff.serviceFeeMax;
+    }
+    return sum + serviceFee;
+  }
+  calculateMaximumAmount(tariff) {
+    return this.calculateAmount(tariff, tariff.duration);
+  }
+};
+
+// src/index.ts
+var JUHUU = class {
+  constructor(config) {
+    this.sessions = new SessionService(config);
+    this.links = new LinkService(config);
+    this.users = new UsersService(config);
+    this.payments = new PaymentsService(config);
+    this.properties = new PropertiesService(config);
+    this.points = new PointsService(config);
+    this.devices = new DevicesService(config);
+    this.deviceTemplates = new DeviceTemplatesService(config);
+    this.locations = new LocationsService(config);
+    this.terms = new TermsService(config);
+    this.tariffs = new TariffsService(config);
+  }
+  /**
+   * Top Level Resources
+   */
+  sessions;
+  links;
+  users;
+  payments;
+  properties;
+  points;
+  devices;
+  deviceTemplates;
+  locations;
+  terms;
+  tariffs;
+};
+export {
+  JUHUU as default
+};