@juhuu/sdk-ts 1.2.2656 → 1.3.1

package/dist/index.mjs

@@ -93,7 +93,7 @@ var Service = class {
         }
         this.logger("accessToken:", token);
         if ((token === null || token === void 0) && authenticationNotOptional === true) {
-          console.error(
+          this.logger(
             "endpoint",
             url,
             "should use authentication but no token was found"
@@ -112,7 +112,7 @@ var Service = class {
           apiKey = currentRequestOptions.apiKey;
         }
         if (apiKey === null) {
-          console.error(
+          this.logger(
             "endpoint",
             url,
             "should use authentication but no apiKey was found"
@@ -165,7 +165,7 @@ var Service = class {
         status: response.status
       };
     } catch (error) {
-      console.error("JUHUU SDK, error sending request: ", error);
+      this.logger("JUHUU SDK, error sending request: ", error);
       responseObject = {
         ok: false,
         data: await response?.json(),
@@ -332,12 +332,6 @@ var Service = class {
     const uri = this.wssBaseUrl + url;
     this.logger("connecting to websocket", uri);
     const socket = io(uri, { transports: ["websocket"] });
-    socket.on("connect", () => {
-      this.logger("connected to websocket", uri);
-    });
-    socket.on("connect_error", (error) => {
-      console.error("Connection error:", error);
-    });
     return socket;
   }
   disconnectFromWebsocket(socket) {
@@ -492,7 +486,10 @@ var SessionService = class extends Service {
           autoRenew: SessionCreateParams.autoRenew,
           type: SessionCreateParams.sessionType,
           isOffSession: SessionCreateParams.isOffSession,
-          userId: SessionCreateParams.userId
+          userId: SessionCreateParams.userId,
+          propertyId: SessionCreateParams.propertyId,
+          scheduledReadyAt: SessionCreateParams.scheduledReadyAt,
+          metadata: SessionCreateParams.metadata
         },
         authenticationNotOptional: true
       },
@@ -671,6 +668,21 @@ var SessionService = class extends Service {
       }
     };
   }
+  async checkAvailability(SessionCheckAvailabilityParams, SessionCheckAvailabilityOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "sessions/checkAvailability",
+        body: {
+          locationId: SessionCheckAvailabilityParams.locationId,
+          tariffId: SessionCheckAvailabilityParams.tariffId,
+          autoRenew: SessionCheckAvailabilityParams.autoRenew
+        },
+        authenticationNotOptional: false
+      },
+      SessionCheckAvailabilityOptions
+    );
+  }
 };
 
 // src/links/links.service.ts
@@ -701,7 +713,9 @@ var LinkService = class extends Service {
         body: {
           propertyId: LinkCreateParams.propertyId,
           name: LinkCreateParams.name,
-          fiveLetterQr: LinkCreateParams.fiveLetterQr
+          fiveLetterQr: LinkCreateParams.fiveLetterQr,
+          referenceObject: LinkCreateParams.referenceObject,
+          referenceObjectId: LinkCreateParams.referenceObjectId
         },
         authenticationNotOptional: true
       },
@@ -747,7 +761,9 @@ var LinkService = class extends Service {
         method: "PATCH",
         url: "links/" + LinkUpdateParams.linkId,
         body: {
-          name: LinkUpdateParams.name
+          name: LinkUpdateParams.name,
+          referenceObject: LinkUpdateParams.referenceObject,
+          referenceObjectId: LinkUpdateParams.referenceObjectId
         },
         authenticationNotOptional: true
       },
@@ -900,7 +916,8 @@ var UsersService = class extends Service {
           billingAddress: UserUpdateParams?.billingAddress,
           taxCodeArray: UserUpdateParams?.taxCodeArray,
           acceptedTermIdArray: UserUpdateParams?.acceptedTermIdArray,
-          group: UserUpdateParams?.group
+          group: UserUpdateParams?.group,
+          expoPushTokenArray: UserUpdateParams?.expoPushTokenArray
         },
         authenticationNotOptional: true
       },
@@ -943,6 +960,19 @@ var UsersService = class extends Service {
       UserDeleteOptions
     );
   }
+  async createIdentityVerificationUrl(UserCreateIdentityVerificationUrlParams, UserCreateIdentityVerificationUrlOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "users/" + UserCreateIdentityVerificationUrlParams.userId + "/createIdentityVerificationUrl",
+        body: {
+          propertyId: UserCreateIdentityVerificationUrlParams.propertyId
+        },
+        authenticationNotOptional: true
+      },
+      UserCreateIdentityVerificationUrlOptions
+    );
+  }
 };
 
 // src/payments/payments.service.ts
@@ -950,6 +980,26 @@ var PaymentsService = class extends Service {
   constructor(config) {
     super(config);
   }
+  async create(PaymentCreateParams, PaymentCreateOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "payments",
+        body: {
+          accountingAreaId: PaymentCreateParams.accountingAreaId,
+          amountWithoutServiceFee: PaymentCreateParams.amountWithoutServiceFee,
+          currencyCode: PaymentCreateParams.currencyCode,
+          propertyId: PaymentCreateParams.propertyId,
+          isOffSession: PaymentCreateParams.isOffSession,
+          salesTaxPercentage: PaymentCreateParams.salesTaxPercentage,
+          userId: PaymentCreateParams.userId,
+          postingRowArray: PaymentCreateParams.postingRowArray
+        },
+        authenticationNotOptional: true
+      },
+      PaymentCreateOptions
+    );
+  }
   async list(PaymentListParams, PaymentListOptions) {
     const queryArray = [];
     if (PaymentListParams.userId !== void 0) {
@@ -1075,8 +1125,7 @@ var PropertiesService = class extends Service {
         url: "properties",
         body: {
           userId: PropertyCreateParams.userId,
-          name: PropertyCreateParams.name,
-          type: PropertyCreateParams.type
+          name: PropertyCreateParams.name
         },
         authenticationNotOptional: true
       },
@@ -1250,6 +1299,13 @@ var PointsService = class extends Service {
     if (PointListParams?.propertyId !== void 0) {
       queryArray.push("propertyId=" + PointListParams.propertyId);
     }
+    if (PointListParams?.invalidAt !== void 0) {
+      if (PointListParams.invalidAt === null) {
+        queryArray.push("invalidAt=");
+      } else {
+        queryArray.push("invalidAt=" + PointListParams.invalidAt.toISOString());
+      }
+    }
     return await super.sendRequest(
       {
         method: "GET",
@@ -1305,7 +1361,8 @@ var DevicesService = class extends Service {
           propertyId: DeviceCreateParams.propertyId,
           deviceTemplateId: DeviceCreateParams.deviceTemplateId,
           name: DeviceCreateParams.name,
-          acceptTerms: DeviceCreateParams.acceptTerms
+          acceptTerms: DeviceCreateParams.acceptTerms,
+          panelId: DeviceCreateParams.panelId
         },
         authenticationNotOptional: true
       },
@@ -1373,7 +1430,9 @@ var DevicesService = class extends Service {
           parameterIdArray: DeviceUpdateParams.parameterIdArray,
           permissionArray: DeviceUpdateParams.permissionArray,
           proximityStrategyArray: DeviceUpdateParams.proximityStrategyArray,
-          simIdArray: DeviceUpdateParams.simIdArray
+          simIdArray: DeviceUpdateParams.simIdArray,
+          panelId: DeviceUpdateParams.panelId,
+          adminQuickActionArray: DeviceUpdateParams.adminQuickActionArray
         },
         authenticationNotOptional: true
       },
@@ -1947,39 +2006,109 @@ var WebsocketsService = class extends Service {
   }
   connect(WebsocketConnectOptions) {
     const socket = super.connectToWebsocket({ url: "websocket" });
-    const pendingRpcResponses = /* @__PURE__ */ new Map();
-    socket.on("rpc.response", (message) => {
-      const resolver = pendingRpcResponses.get(message.id);
-      if (resolver !== void 0) {
-        resolver(message);
-        pendingRpcResponses.delete(message.id);
+    socket.on("connect", () => {
+      this.logger("connected to websocket");
+    });
+    socket.on(
+      "subscription_success",
+      (message) => {
+        this.logger("Subscription success:", message);
+      }
+    );
+    socket.on(
+      "unsubscription_success",
+      (message) => {
+        this.logger("Unsubscription success:", message);
       }
+    );
+    socket.on("error", (error) => {
+      this.logger("WebSocket error:", error);
     });
-    const onQueryUpdate = (callback) => {
-      socket.on("query.update", (message) => {
+    const onLocationUpdate = (callback) => {
+      socket.on(
+        "location_update",
+        (message) => {
+          callback(message);
+        }
+      );
+    };
+    const onParameterUpdate = (callback) => {
+      socket.on(
+        "parameter_update",
+        (message) => {
+          callback(message);
+        }
+      );
+    };
+    const onSessionUpdate = (callback) => {
+      socket.on("session_update", (message) => {
         callback(message);
       });
     };
+    const onConnect = (callback) => {
+      socket.on("connect", callback);
+    };
+    const onDisconnect = (callback) => {
+      socket.on("disconnect", callback);
+    };
+    const onReconnect = (callback) => {
+      socket.on("reconnect", callback);
+    };
+    const onConnectError = (callback) => {
+      socket.on("connect_error", callback);
+    };
+    const onReconnectAttempt = (callback) => {
+      socket.on("reconnect_attempt", callback);
+    };
+    const onReconnectError = (callback) => {
+      socket.on("reconnect_error", callback);
+    };
+    const onReconnectFailed = (callback) => {
+      socket.on("reconnect_failed", callback);
+    };
     return {
-      subscribe: (rooms) => {
-        socket.emit("subscribe", { rooms });
+      subscribe: (locationIdArray, parameterIdArray, sessionIdArray) => {
+        socket.emit("subscribe", {
+          locationIdArray: locationIdArray || [],
+          parameterIdArray: parameterIdArray || [],
+          sessionIdArray: sessionIdArray || []
+        });
       },
-      unsubscribe: (rooms) => {
-        socket.emit("unsubscribe", { rooms });
+      unsubscribeFromLocations: (locationIdArray) => {
+        socket.emit("unsubscribe", { locationIdArray });
       },
-      subscribeQuery: (payload) => {
-        socket.emit("subscribeQuery", payload);
+      unsubscribeFromParameters: (parameterIdArray) => {
+        socket.emit("unsubscribe", { parameterIdArray });
       },
-      unsubscribeQuery: (payload) => {
-        socket.emit("unsubscribeQuery", payload);
+      unsubscribeFromSessions: (sessionIdArray) => {
+        socket.emit("unsubscribe", { sessionIdArray });
       },
-      rpc: async (payload) => {
-        return await new Promise((resolve) => {
-          pendingRpcResponses.set(payload.id, resolve);
-          socket.emit("rpc", payload);
+      unsubscribe: (locationIdArray, parameterIdArray, sessionIdArray) => {
+        socket.emit("unsubscribe", {
+          locationIdArray: locationIdArray || [],
+          parameterIdArray: parameterIdArray || [],
+          sessionIdArray: sessionIdArray || []
         });
       },
-      onQueryUpdate,
+      ping: (data) => {
+        socket.emit("ping", data);
+      },
+      onLocationUpdate,
+      onParameterUpdate,
+      onSessionUpdate,
+      onConnect,
+      onDisconnect,
+      onReconnect,
+      onConnectError,
+      onReconnectAttempt,
+      onReconnectError,
+      onReconnectFailed,
+      onPong: (callback) => {
+        socket.on("pong", callback);
+      },
+      isConnected: () => {
+        return socket.connected;
+      },
       close: () => {
         socket.close();
       }
@@ -2447,6 +2576,19 @@ var ArticlesService = class extends Service {
       ArticleTranslateOptions
     );
   }
+  async pdf(ArticlePdfParams, ArticlePdfOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "articles/" + ArticlePdfParams.articleId + "/pdf",
+        body: {
+          languageCodeArray: ArticlePdfParams.languageCodeArray
+        },
+        authenticationNotOptional: false
+      },
+      ArticlePdfOptions
+    );
+  }
 };
 
 // src/chats/chats.service.ts
@@ -3228,6 +3370,8 @@ var IncidentsService = class extends Service {
           type: IncidentCreateParams.type,
           deviceId: IncidentCreateParams.deviceId,
           locationId: IncidentCreateParams.locationId,
+          parameterAnomalyGroupId: IncidentCreateParams.parameterAnomalyGroupId,
+          simId: IncidentCreateParams.simId,
           incidentTemplateId: IncidentCreateParams.incidentTemplateId,
           severity: IncidentCreateParams.severity
         },
@@ -3292,6 +3436,19 @@ var IncidentsService = class extends Service {
       IncidentUpdateOptions
     );
   }
+  async notifyAffected(IncidentNotifyAffectedParams, IncidentNotifyAffectedOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "incidents/" + IncidentNotifyAffectedParams.incidentId + "/notifyAffected",
+        body: {
+          message: IncidentNotifyAffectedParams.message
+        },
+        authenticationNotOptional: true
+      },
+      IncidentNotifyAffectedOptions
+    );
+  }
 };
 
 // src/parameterAnomalyGroups/parameterAnomalyGroups.service.ts
@@ -3366,7 +3523,9 @@ var ParameterAnomalyGroupsService = class extends Service {
         method: "PATCH",
         url: "parameterAnomalyGroups/" + ParameterAnomalyGroupUpdateParams.parameterAnomalyGroupId,
         body: {
-          parameterAnomalyGroupId: ParameterAnomalyGroupUpdateParams.parameterAnomalyGroupId
+          parameterAnomalyGroupTrackerId: ParameterAnomalyGroupUpdateParams.parameterAnomalyGroupTrackerId,
+          name: ParameterAnomalyGroupUpdateParams.name,
+          featureReferenceParameterIdArray: ParameterAnomalyGroupUpdateParams.featureReferenceParameterIdArray
         },
         authenticationNotOptional: true
       },
@@ -3397,7 +3556,8 @@ var ParameterAnomalyGroupTrackersService = class extends Service {
         method: "POST",
         url: "parameterAnomalyGroupTrackers",
         body: {
-          propertyId: ParameterAnomalyGroupTrackerCreateParams.propertyId
+          propertyId: ParameterAnomalyGroupTrackerCreateParams.propertyId,
+          name: ParameterAnomalyGroupTrackerCreateParams.name
         },
         authenticationNotOptional: true
       },
@@ -3450,7 +3610,9 @@ var ParameterAnomalyGroupTrackersService = class extends Service {
         method: "PATCH",
         url: "parameterAnomalyGroupTrackers/" + ParameterAnomalyGroupTrackerUpdateParams.parameterAnomalyGroupTrackerId,
         body: {
-          name: ParameterAnomalyGroupTrackerUpdateParams.name
+          name: ParameterAnomalyGroupTrackerUpdateParams.name,
+          description: ParameterAnomalyGroupTrackerUpdateParams.description,
+          dataType: ParameterAnomalyGroupTrackerUpdateParams.dataType
         },
         authenticationNotOptional: true
       },
@@ -3481,6 +3643,59 @@ var ParameterAnomalyGroupTrackersService = class extends Service {
   }
 };
 
+// src/parameterAnomalyGroupTrackerTraces/parameterAnomalyGroupTrackerTraces.service.ts
+var ParameterAnomalyGroupTrackerTracesService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async list(ParameterAnomalyGroupTrackerTraceListParams, ParameterAnomalyGroupTrackerTraceListOptions) {
+    const queryArray = [];
+    if (ParameterAnomalyGroupTrackerTraceListParams?.propertyId !== void 0) {
+      queryArray.push("propertyId=" + ParameterAnomalyGroupTrackerTraceListParams.propertyId);
+    }
+    if (ParameterAnomalyGroupTrackerTraceListParams?.parameterAnomalyGroupTrackerId !== void 0) {
+      queryArray.push("parameterAnomalyGroupTrackerId=" + ParameterAnomalyGroupTrackerTraceListParams.parameterAnomalyGroupTrackerId);
+    }
+    if (ParameterAnomalyGroupTrackerTraceListOptions?.limit !== void 0) {
+      queryArray.push("limit=" + ParameterAnomalyGroupTrackerTraceListOptions.limit);
+    }
+    if (ParameterAnomalyGroupTrackerTraceListOptions?.skip !== void 0) {
+      queryArray.push("skip=" + ParameterAnomalyGroupTrackerTraceListOptions.skip);
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "parameterAnomalyGroupTrackerTraces?" + queryArray.join("&"),
+        body: void 0,
+        authenticationNotOptional: false
+      },
+      ParameterAnomalyGroupTrackerTraceListOptions
+    );
+  }
+  async retrieve(ParameterAnomalyGroupTrackerTraceRetrieveParams, ParameterAnomalyGroupTrackerTraceRetrieveOptions) {
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "parameterAnomalyGroupTrackerTraces/" + ParameterAnomalyGroupTrackerTraceRetrieveParams.parameterAnomalyGroupTrackerTraceId,
+        body: void 0,
+        authenticationNotOptional: false
+      },
+      ParameterAnomalyGroupTrackerTraceRetrieveOptions
+    );
+  }
+  async delete(ParameterAnomalyGroupTrackerTraceDeleteParams, ParameterAnomalyGroupTrackerTraceDeleteOptions) {
+    return await super.sendRequest(
+      {
+        method: "DELETE",
+        url: "parameterAnomalyGroupTrackerTraces/" + ParameterAnomalyGroupTrackerTraceDeleteParams.parameterAnomalyGroupTrackerTraceId,
+        body: void 0,
+        authenticationNotOptional: false
+      },
+      ParameterAnomalyGroupTrackerTraceDeleteOptions
+    );
+  }
+};
+
 // src/emz/emz.service.ts
 var EmzService = class extends Service {
   constructor(config) {
@@ -3612,22 +3827,6 @@ var FlowsService = class extends Service {
       FlowExecuteOptions
     );
   }
-  areInputsAvailable(block, outputStore, edgeArray) {
-    if (block.in === null || block.in === void 0) {
-      return true;
-    }
-    return Object.values(block.in).every((edgeId) => {
-      const edge = edgeArray.find((e) => e.id === edgeId);
-      if (edge === void 0) {
-        return false;
-      }
-      if (edge.type === "control") {
-        return true;
-      }
-      const srcOutputs = outputStore[edge.from.blockId];
-      return srcOutputs !== null && srcOutputs !== void 0 && edge.from.output in srcOutputs;
-    });
-  }
   resolveInputs(block, outputStore, edgeArray) {
     const inputs = {};
     if (block.in === void 0) {
@@ -3674,9 +3873,7 @@ var FlowsService = class extends Service {
       for (const param of defs) {
         const value = context[param.name];
         if (value === void 0 && param.required) {
-          throw new Error(
-            `Missing required input parameter '${param.name}'`
-          );
+          throw new Error(`Missing required input parameter '${param.name}'`);
         }
         outputs[param.name] = value;
       }
@@ -3709,212 +3906,283 @@ var FlowsService = class extends Service {
         }
         execInput[key] = value;
       }
-      const { output } = await this.executeLocally(finalFlowId, execInput);
-      return { output };
+      const response = await this.execute({
+        flowId: finalFlowId,
+        input: execInput
+      });
+      if (response.ok === false) {
+        throw new Error(
+          `Failed to execute flow: ${response.data?.message || "Unknown error"}`
+        );
+      }
+      return { output: response.data.output };
     },
     "end.custom": async (inputs) => {
       return { output: { ...inputs } };
     },
-    // Placeholder implementations for other block types (they will throw errors if used)
-    "start.quickAction.location": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "start.session.update": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "start.location.update": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "start.parameter.update": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "const.number": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "const.text": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "const.boolean": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "math.add": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "math.subtract": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "const.number": async (_inputs, block) => {
+      const { data } = block;
+      return { output: { value: data?.value } };
     },
-    "math.multiply": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "const.text": async (_inputs, block) => {
+      const { data } = block;
+      return { output: { value: data?.value } };
     },
-    "math.divide": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "const.boolean": async (_inputs, block) => {
+      const { data } = block;
+      return { output: { value: data?.value } };
     },
-    "map.destructure": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "math.add": async (inputs, block) => {
+      const mb = block;
+      const inA = inputs.a;
+      const inB = inputs.b;
+      const defaultA = mb.data.a ?? 0;
+      const defaultB = mb.data.b ?? 0;
+      const a = inA !== void 0 ? inA : defaultA;
+      const b = inB !== void 0 ? inB : defaultB;
+      return { output: { result: a + b } };
     },
-    "parameter.retrieve": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "math.subtract": async (inputs, block) => {
+      const mb = block;
+      const inA = inputs.a;
+      const inB = inputs.b;
+      const defaultA = mb.data.a ?? 0;
+      const defaultB = mb.data.b ?? 0;
+      const a = inA !== void 0 ? inA : defaultA;
+      const b = inB !== void 0 ? inB : defaultB;
+      return { output: { result: a - b } };
     },
-    "property.retrieve": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "math.multiply": async (inputs, block) => {
+      const mb = block;
+      const inA = inputs.a;
+      const inB = inputs.b;
+      const defaultA = mb.data.a ?? 0;
+      const defaultB = mb.data.b ?? 0;
+      const a = inA !== void 0 ? inA : defaultA;
+      const b = inB !== void 0 ? inB : defaultB;
+      return { output: { result: a * b } };
     },
-    "location.retrieve": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "math.divide": async (inputs, block) => {
+      const mb = block;
+      const inA = inputs.a;
+      const inB = inputs.b;
+      const defaultA = mb.data.a ?? 0;
+      const defaultB = mb.data.b ?? 1;
+      const a = inA !== void 0 ? inA : defaultA;
+      const b = inB !== void 0 ? inB : defaultB;
+      return { output: { result: a / b } };
     },
-    "session.retrieve": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "device.retrieve": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "user.retrieve": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "user.create": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "incident.retrieve": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "parameter.update": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "device.update": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "location.update": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "property.update": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "session.terminate": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "system.log": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "ui.navigate.screen": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "incident.create": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "control.switch": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "http.patch": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "http.get": async () => {
-      throw new Error("Block type not implemented in executeLocally");
-    },
-    "http.post": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "map.destructure": async (inputs, block) => {
+      if (block.type !== "map.destructure") {
+        throw new Error(
+          `Expected block type 'map.destructure', got '${block.type}'`
+        );
+      }
+      const source = inputs.map;
+      const mb = block;
+      const outputs = {};
+      const keys = mb.data.keys ?? [];
+      for (const key of keys) {
+        outputs[key] = source[key];
+      }
+      return { output: outputs };
     },
-    "http.delete": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "map.construct": async (inputs, block) => {
+      if (block.type !== "map.construct") {
+        throw new Error(
+          `Expected block type 'map.construct', got '${block.type}'`
+        );
+      }
+      const mb = block;
+      const constructedMap = {};
+      const keys = mb.data.keys ?? [];
+      const inputValues = inputs;
+      for (const key of keys) {
+        constructedMap[key] = inputValues[key];
+      }
+      return { output: { map: constructedMap } };
     },
-    "http.put": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "variable.set": async (inputs, block, context) => {
+      const { key, value } = inputs;
+      const typedBlock = block;
+      const finalKey = this.isInputConnected(typedBlock, "key") ? key : typedBlock.data?.key;
+      const finalValue = this.isInputConnected(typedBlock, "value") ? value : typedBlock.data?.value;
+      if (finalKey === void 0 || finalKey === null) {
+        throw new Error("Variable key is required");
+      }
+      if (!context.variables) {
+        context.variables = /* @__PURE__ */ new Map();
+      }
+      if (finalKey.includes(".")) {
+        const keys = finalKey.split(".");
+        const rootKey = keys[0];
+        let rootValue = context.variables.get(rootKey);
+        if (rootValue === void 0 || rootValue === null) {
+          rootValue = {};
+          context.variables.set(rootKey, rootValue);
+        }
+        const finalPropertyKey = keys[keys.length - 1];
+        const parentKeys = keys.slice(1, -1);
+        let current = rootValue;
+        for (const key2 of parentKeys) {
+          if (current[key2] === void 0 || current[key2] === null) {
+            current[key2] = {};
+          }
+          current = current[key2];
+        }
+        current[finalPropertyKey] = finalValue;
+      } else {
+        context.variables.set(finalKey, finalValue);
+      }
+      return { output: { success: true } };
     },
-    "mqtt.send": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "variable.get": async (inputs, block, context) => {
+      const { key } = inputs;
+      const typedBlock = block;
+      const finalKey = this.isInputConnected(typedBlock, "key") ? key : typedBlock.data?.key;
+      if (finalKey === void 0 || finalKey === null) {
+        throw new Error("Variable key is required");
+      }
+      if (!context.variables) {
+        context.variables = /* @__PURE__ */ new Map();
+      }
+      let retrievedValue;
+      if (finalKey.includes(".")) {
+        const keys = finalKey.split(".");
+        const rootKey = keys[0];
+        const rootValue = context.variables.get(rootKey);
+        if (rootValue !== void 0 && rootValue !== null) {
+          retrievedValue = keys.slice(1).reduce((obj, key2) => {
+            return obj && obj[key2];
+          }, rootValue);
+        } else {
+          retrievedValue = void 0;
+        }
+      } else {
+        retrievedValue = context.variables.get(finalKey);
+      }
+      return { output: { value: retrievedValue } };
     }
   };
-  async executeLocally(flowId, context = {}) {
+  async executeLocally(FlowExecuteLocallyParams, FlowExecuteLocallyOptions) {
     const logArray = [];
     logArray.push({
       createdAt: /* @__PURE__ */ new Date(),
-      message: `Starting local execution of flow '${flowId}'`,
+      message: `Starting local execution of flow '${FlowExecuteLocallyParams.flowId}'`,
       severity: "info"
     });
-    const flowResponse = await this.retrieve({ flowId });
-    if (!flowResponse.ok) {
-      throw new Error(`Failed to retrieve flow: ${flowResponse.data?.message || "Unknown error"}`);
-    }
-    const flow = flowResponse.data.flow;
-    const blocksById = new Map(
-      flow.nodeArray.map((b) => [b.id, b])
-    );
-    blocksById.set(flow.startNode.id, flow.startNode);
-    const edgeArray = flow.edgeArray;
-    const outputStore = {};
-    const runBlock = async (block) => {
-      logArray.push({
-        createdAt: /* @__PURE__ */ new Date(),
-        message: `Running block ${block.type} (${block.id})`,
-        severity: "info"
-      });
-      const inputs = this.resolveInputs(block, outputStore, edgeArray);
-      const executor = this.blockExecutors[block.type];
-      if (executor === void 0 || executor === null) {
-        throw new Error(`No executor for ${block.type}`);
-      }
-      const raw = await executor(inputs, block, context);
-      const { flowBranch, output } = raw;
-      outputStore[block.id] = output;
-      if (raw.logArray !== void 0) {
-        logArray.push(...raw.logArray);
-      }
-      logArray.push({
-        createdAt: /* @__PURE__ */ new Date(),
-        message: `Block ${block.type} (${block.id}) executed successfully`,
-        severity: "info"
+    try {
+      const flowResponse = await this.retrieve({
+        flowId: FlowExecuteLocallyParams.flowId
       });
-      return flowBranch ?? null;
-    };
-    const getNext = (fromId, branch) => {
-      let ce = edgeArray.find(
-        (e) => e.type === "control" && e.from.blockId === fromId && (e.from.output ?? null) === branch
-      );
-      if ((ce === null || ce === void 0) && branch === null) {
-        ce = edgeArray.find(
-          (e) => e.type === "control" && e.from.blockId === fromId
+      if (!flowResponse.ok) {
+        throw new Error(
+          `Failed to retrieve flow: ${flowResponse.data?.message || "Unknown error"}`
         );
       }
-      if (ce === null || ce === void 0) {
-        return null;
-      }
-      return blocksById.get(ce.to.blockId) ?? null;
-    };
-    if (flow.startNode.type.startsWith("start.") === false) {
-      throw new Error(
-        `Flow ${flowId} has an invalid start block that is not of type 'start.'`
+      const flow = flowResponse.data.flow;
+      const blocksById = new Map(
+        flow.nodeArray.map((b) => [b.id, b])
       );
-    }
-    let current = flow.startNode;
-    await runBlock(current);
-    const next = getNext(current.id, null);
-    if (next === null) {
-      return {
-        output: {},
-        logArray
+      blocksById.set(flow.startNode.id, flow.startNode);
+      const edgeArray = flow.edgeArray;
+      const outputStore = {};
+      const mergedBlockExecutors = {
+        ...this.blockExecutors,
+        ...FlowExecuteLocallyOptions?.blockExecutors || {}
       };
-    }
-    current = next;
-    while (current.type.startsWith("end.") === false) {
-      const branch = await runBlock(current);
-      const next2 = getNext(current.id, branch);
-      if (next2 === null) {
+      const runBlock = async (block) => {
+        logArray.push({
+          createdAt: /* @__PURE__ */ new Date(),
+          message: `Running block ${block.type} (${block.id})`,
+          severity: "info"
+        });
+        const inputs = this.resolveInputs(block, outputStore, edgeArray);
+        const executor = mergedBlockExecutors[block.type];
+        if (executor === void 0 || executor === null) {
+          throw new Error(
+            `Block type '${block.type}' is not implemented in the local executor`
+          );
+        }
+        const raw = await executor(
+          inputs,
+          block,
+          FlowExecuteLocallyParams.input ?? {}
+        );
+        const { flowBranch, output } = raw;
+        outputStore[block.id] = output;
+        if (raw.logArray !== void 0) {
+          logArray.push(...raw.logArray);
+        }
+        logArray.push({
+          createdAt: /* @__PURE__ */ new Date(),
+          message: `Block ${block.type} (${block.id}) executed successfully`,
+          severity: "info"
+        });
+        return flowBranch ?? null;
+      };
+      const getNext = (fromId, branch) => {
+        let ce = edgeArray.find(
+          (e) => e.type === "control" && e.from.blockId === fromId && (e.from.output ?? null) === branch
+        );
+        if ((ce === null || ce === void 0) && branch === null) {
+          ce = edgeArray.find(
+            (e) => e.type === "control" && e.from.blockId === fromId
+          );
+        }
+        if (ce === null || ce === void 0) {
+          return null;
+        }
+        return blocksById.get(ce.to.blockId) ?? null;
+      };
+      if (flow.startNode.type.startsWith("start.") === false) {
+        throw new Error(
+          `Flow ${FlowExecuteLocallyParams.flowId} has an invalid start block that is not of type 'start.'`
+        );
+      }
+      let current = flow.startNode;
+      await runBlock(current);
+      const next = getNext(current.id, null);
+      if (next === null) {
         return {
           output: {},
           logArray
         };
       }
-      current = next2;
-    }
-    await runBlock(current);
-    const endBlock = current;
-    const result = {};
-    const definitions = endBlock.data.outputParamDefinitionArray ?? [];
-    for (const def of definitions) {
-      result[def.name] = outputStore[current.id]?.[def.name] ?? null;
+      current = next;
+      while (current.type.startsWith("end.") === false) {
+        const branch = await runBlock(current);
+        const next2 = getNext(current.id, branch);
+        if (next2 === null) {
+          return {
+            output: {},
+            logArray
+          };
+        }
+        current = next2;
+      }
+      await runBlock(current);
+      const endBlock = current;
+      const result = {};
+      const definitions = endBlock.data.outputParamDefinitionArray ?? [];
+      for (const def of definitions) {
+        result[def.name] = outputStore[current.id]?.[def.name] ?? null;
+      }
+      return {
+        output: result,
+        logArray
+      };
+    } catch (error) {
+      logArray.push({
+        createdAt: /* @__PURE__ */ new Date(),
+        message: `Flow execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        severity: "error"
+      });
+      return {
+        output: {},
+        logArray
+      };
     }
-    return {
-      output: result,
-      logArray
-    };
   }
 };
 
@@ -4472,26 +4740,14 @@ var BenefitCardsService = class extends Service {
         method: "POST",
         url: "benefitCards",
         body: {
+          propertyId: params.propertyId,
+          name: params.name,
+          imageLight: params.imageLight,
+          imageDark: params.imageDark,
           userId: params.userId,
-          cardNumber: params.cardNumber,
-          cardHolderName: params.cardHolderName,
-          type: params.type,
-          status: params.status,
-          benefits: params.benefits,
-          limits: params.limits,
-          metadata: params.metadata,
-          pointsBalance: params.pointsBalance,
-          cashbackBalance: params.cashbackBalance,
-          totalSavings: params.totalSavings,
-          totalSpent: params.totalSpent,
-          transactionCount: params.transactionCount,
-          expiresAt: params.expiresAt,
-          isDigital: params.isDigital,
-          isTransferable: params.isTransferable,
-          requiresPin: params.requiresPin,
-          pin: params.pin,
-          qrCode: params.qrCode,
-          barcode: params.barcode
+          reference: params.reference,
+          text: params.text,
+          metadata: params.metadata
         },
         authenticationNotOptional: true
       },
@@ -4500,38 +4756,14 @@ var BenefitCardsService = class extends Service {
   }
   async list(params, options) {
     const queryArray = [];
+    if (params?.propertyId !== void 0) {
+      queryArray.push("propertyId=" + params.propertyId);
+    }
     if (params?.userId !== void 0) {
       queryArray.push("userId=" + params.userId);
     }
-    if (params?.cardNumber !== void 0) {
-      queryArray.push("cardNumber=" + params.cardNumber);
-    }
-    if (params?.cardHolderName !== void 0) {
-      queryArray.push("cardHolderName=" + params.cardHolderName);
-    }
-    if (params?.type !== void 0) {
-      queryArray.push("type=" + params.type);
-    }
-    if (params?.status !== void 0) {
-      queryArray.push("status=" + params.status);
-    }
-    if (params?.issuer !== void 0) {
-      queryArray.push("issuer=" + params.issuer);
-    }
-    if (params?.brand !== void 0) {
-      queryArray.push("brand=" + params.brand);
-    }
-    if (params?.level !== void 0) {
-      queryArray.push("level=" + params.level);
-    }
-    if (params?.isDigital !== void 0) {
-      queryArray.push("isDigital=" + params.isDigital);
-    }
-    if (params?.isTransferable !== void 0) {
-      queryArray.push("isTransferable=" + params.isTransferable);
-    }
-    if (params?.requiresPin !== void 0) {
-      queryArray.push("requiresPin=" + params.requiresPin);
+    if (params?.text !== void 0) {
+      queryArray.push("text=" + params.text);
     }
     if (options?.limit !== void 0) {
       queryArray.push("limit=" + options.limit);
@@ -4544,19 +4776,18 @@ var BenefitCardsService = class extends Service {
         method: "GET",
         url: "benefitCards?" + queryArray.join("&"),
         body: void 0,
-        authenticationNotOptional: false
+        authenticationNotOptional: true
       },
       options
     );
   }
   async retrieve(params, options) {
-    const queryArray = [];
     return await super.sendRequest(
       {
         method: "GET",
-        url: "benefitCards/" + params.benefitCardId + "?" + queryArray.join("&"),
+        url: "benefitCards/" + params.benefitCardId,
         body: void 0,
-        authenticationNotOptional: false
+        authenticationNotOptional: true
       },
       options
     );
@@ -4567,26 +4798,13 @@ var BenefitCardsService = class extends Service {
         method: "PATCH",
         url: "benefitCards/" + params.benefitCardId,
         body: {
+          name: params.name,
+          imageLight: params.imageLight,
+          imageDark: params.imageDark,
           userId: params.userId,
-          cardNumber: params.cardNumber,
-          cardHolderName: params.cardHolderName,
-          type: params.type,
-          status: params.status,
-          benefits: params.benefits,
-          limits: params.limits,
-          metadata: params.metadata,
-          pointsBalance: params.pointsBalance,
-          cashbackBalance: params.cashbackBalance,
-          totalSavings: params.totalSavings,
-          totalSpent: params.totalSpent,
-          transactionCount: params.transactionCount,
-          expiresAt: params.expiresAt,
-          isDigital: params.isDigital,
-          isTransferable: params.isTransferable,
-          requiresPin: params.requiresPin,
-          pin: params.pin,
-          qrCode: params.qrCode,
-          barcode: params.barcode
+          reference: params.reference,
+          text: params.text,
+          metadata: params.metadata
         },
         authenticationNotOptional: true
       },
@@ -4604,6 +4822,17 @@ var BenefitCardsService = class extends Service {
       options
     );
   }
+  async copy(params, options) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "benefitCards/" + params.benefitCardId + "/copy",
+        authenticationNotOptional: true,
+        body: void 0
+      },
+      options
+    );
+  }
 };
 
 // src/catalogs/catalogs.service.ts
@@ -4927,15 +5156,32 @@ var KitsService = class extends Service {
     super(config);
   }
   async create(params, options) {
+    const body = {
+      name: params.name,
+      propertyId: params.propertyId,
+      type: params.type
+    };
+    if (params.type === "controlKitV1") {
+      body.simIdArray = params.simIdArray;
+      body.signalStrengthPercentage = params.signalStrengthPercentage;
+      body.teltonikaSerialNumber = params.teltonikaSerialNumber;
+    } else if (params.type === "tapkeyV1") {
+      body.physicalLockId = params.physicalLockId;
+      body.boundLockId = params.boundLockId;
+      body.ownerAccountId = params.ownerAccountId;
+      body.ipId = params.ipId;
+    } else if (params.type === "emzV1") {
+      body.contractId = params.contractId;
+      body.targetHardwareId = params.targetHardwareId;
+      body.userId = params.userId;
+      body.username = params.username;
+      body.password = params.password;
+    }
     return await super.sendRequest(
       {
         method: "POST",
         url: "kits",
-        body: {
-          name: params.name,
-          propertyId: params.propertyId,
-          template: params.template
-        },
+        body,
         authenticationNotOptional: true
       },
       options
@@ -4983,7 +5229,8 @@ var KitsService = class extends Service {
         method: "PATCH",
         url: "kits/" + params.kitId,
         body: {
-          name: params.name
+          name: params.name,
+          flowIdArray: params.flowIdArray
         },
         authenticationNotOptional: true
       },
@@ -5001,6 +5248,30 @@ var KitsService = class extends Service {
       options
     );
   }
+  async attachProperty(params, options) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "kits/" + params.kitId + "/attachProperty",
+        body: {
+          propertyId: params.propertyId
+        },
+        authenticationNotOptional: true
+      },
+      options
+    );
+  }
+  async detachProperty(params, options) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "kits/" + params.kitId + "/detachProperty",
+        body: void 0,
+        authenticationNotOptional: true
+      },
+      options
+    );
+  }
 };
 
 // src/panels/panels.service.ts
@@ -5018,7 +5289,10 @@ var PanelsService = class extends Service {
           name: params.name,
           layoutBlockArray: params.layoutBlockArray,
           highlightLayoutBlockArray: params.highlightLayoutBlockArray,
-          localParameterArray: params.localParameterArray
+          variables: params.variables,
+          display: params.display,
+          permissionArray: params.permissionArray,
+          proximityStrategyArray: params.proximityStrategyArray
         },
         authenticationNotOptional: true
       },
@@ -5048,6 +5322,9 @@ var PanelsService = class extends Service {
   }
   async retrieve(params, options) {
     const queryArray = [];
+    if (options?.expand !== void 0) {
+      queryArray.push("expand=" + options.expand.join(","));
+    }
     return await super.sendRequest(
       {
         method: "GET",
@@ -5067,8 +5344,10 @@ var PanelsService = class extends Service {
           name: params.name,
           layoutBlockArray: params.layoutBlockArray,
           highlightLayoutBlockArray: params.highlightLayoutBlockArray,
-          localParameterArray: params.localParameterArray,
-          display: params.display
+          variables: params.variables,
+          display: params.display,
+          permissionArray: params.permissionArray,
+          proximityStrategyArray: params.proximityStrategyArray
         },
         authenticationNotOptional: true
       },
@@ -5239,6 +5518,83 @@ var PricesService = class extends Service {
   }
 };
 
+// src/applications/applications.service.ts
+var ApplicationsService = class extends Service {
+  constructor(config) {
+    super(config);
+  }
+  async create(ApplicationCreateParams, ApplicationOptions) {
+    return await super.sendRequest(
+      {
+        method: "POST",
+        url: "applications",
+        body: {
+          propertyId: ApplicationCreateParams.propertyId,
+          colorScheme: ApplicationCreateParams.colorScheme,
+          appIconLight: ApplicationCreateParams.appIconLight,
+          appIconDark: ApplicationCreateParams.appIconDark
+        },
+        authenticationNotOptional: true
+      },
+      ApplicationOptions
+    );
+  }
+  async retrieve(ApplicationRetrieveParams, ApplicationRetrieveOptions) {
+    const queryArray = [];
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "applications/" + ApplicationRetrieveParams.applicationId + "?" + queryArray.join("&"),
+        body: void 0,
+        authenticationNotOptional: false
+      },
+      ApplicationRetrieveOptions
+    );
+  }
+  async list(ApplicationListParams, ApplicationListOptions) {
+    const queryArray = [];
+    if (ApplicationListParams?.propertyId !== void 0) {
+      queryArray.push("propertyId=" + ApplicationListParams.propertyId);
+    }
+    return await super.sendRequest(
+      {
+        method: "GET",
+        url: "applications?" + queryArray.join("&"),
+        body: void 0,
+        authenticationNotOptional: false
+      },
+      ApplicationListOptions
+    );
+  }
+  async update(ApplicationUpdateParams, ApplicationUpdateOptions) {
+    return await super.sendRequest(
+      {
+        method: "PATCH",
+        url: "applications/" + ApplicationUpdateParams.applicationId,
+        body: {
+          colorScheme: ApplicationUpdateParams.colorScheme,
+          appIconLight: ApplicationUpdateParams.appIconLight,
+          appIconDark: ApplicationUpdateParams.appIconDark,
+          status: ApplicationUpdateParams.status
+        },
+        authenticationNotOptional: true
+      },
+      ApplicationUpdateOptions
+    );
+  }
+  async delete(ApplicationDeleteParams, ApplicationDeleteOptions) {
+    return await super.sendRequest(
+      {
+        method: "DELETE",
+        url: "applications/" + ApplicationDeleteParams.applicationId,
+        authenticationNotOptional: true,
+        body: void 0
+      },
+      ApplicationDeleteOptions
+    );
+  }
+};
+
 // src/types/types.ts
 var LanguageCodeArray = [
   "en",
@@ -5422,6 +5778,7 @@ var Juhuu = class {
     this.incidents = new IncidentsService(config);
     this.parameterAnomalyGroups = new ParameterAnomalyGroupsService(config);
     this.parameterAnomalyGroupTrackers = new ParameterAnomalyGroupTrackersService(config);
+    this.parameterAnomalyGroupTrackerTraces = new ParameterAnomalyGroupTrackerTracesService(config);
     this.emz = new EmzService(config);
     this.flows = new FlowsService(config);
     this.flowTraces = new FlowTracesService(config);
@@ -5436,6 +5793,7 @@ var Juhuu = class {
     this.kits = new KitsService(config);
     this.panels = new PanelsService(config);
     this.prices = new PricesService(config);
+    this.applications = new ApplicationsService(config);
   }
   /**
    * Top Level Resources
@@ -5473,6 +5831,7 @@ var Juhuu = class {
   incidents;
   parameterAnomalyGroups;
   parameterAnomalyGroupTrackers;
+  parameterAnomalyGroupTrackerTraces;
   emz;
   flows;
   flowTraces;
@@ -5487,6 +5846,7 @@ var Juhuu = class {
   kits;
   panels;
   prices;
+  applications;
 };
 var JUHUU;
 ((JUHUU2) => {