@camunda8/orchestration-cluster-api 10.0.0-alpha.30 → 10.0.0-alpha.32

package/dist/{chunk-SHE5T54L.js → chunk-WHBUDCPU.js}

@@ -5027,7 +5027,7 @@ function installAuthInterceptor(client2, getStrategy, getAuthHeaders) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.30";
+var packageVersion = "10.0.0-alpha.32";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -5485,18 +5485,18 @@ function unwrapForInspection(s) {
       continue;
     }
     if (t === "ZodIntersection") {
-      const left2 = cur._def.left;
-      const right2 = cur._def.right;
-      if (left2?._def?.typeName === "ZodObject" && right2?._def?.typeName === "ZodObject") {
+      const left = cur._def.left;
+      const right = cur._def.right;
+      if (left?._def?.typeName === "ZodObject" && right?._def?.typeName === "ZodObject") {
         try {
-          const leftShapeFn = left2._def.shape;
-          const rightShapeFn = right2._def.shape;
+          const leftShapeFn = left._def.shape;
+          const rightShapeFn = right._def.shape;
           const merged = { ...leftShapeFn(), ...rightShapeFn() };
           return ZodObject.create(merged);
         } catch {
         }
       }
-      cur = left2;
+      cur = left;
       continue;
     }
     break;
@@ -7046,7 +7046,7 @@ var CamundaClient = class {
   _schemasPromise = null;
   _loadSchemas() {
     if (!this._schemasPromise) {
-      this._schemasPromise = import("./zod.gen-CGU4FBRF.js");
+      this._schemasPromise = import("./zod.gen-2LVIU5XR.js");
     }
     return this._schemasPromise;
   }
@@ -20663,128 +20663,6 @@ var CamundaClient = class {
   }
 };
 
-// src/fp-ts.ts
-var left = (e) => ({ _tag: "Left", left: e });
-var right = (a) => ({ _tag: "Right", right: a });
-var isLeft = (e) => e._tag === "Left";
-var isRight = (e) => e._tag === "Right";
-function toDomainError(err) {
-  if (err instanceof CamundaValidationError) return err;
-  if (err instanceof EventualConsistencyTimeoutError) return err;
-  if (err instanceof Error) return err;
-  if (typeof err === "object") return err;
-  return { message: String(err) };
-}
-function classifyDomainError(err) {
-  if (err instanceof CamundaValidationError) return "validation";
-  if (err instanceof EventualConsistencyTimeoutError) return "timeout";
-  if (!(err instanceof Error) || err.status !== void 0) return "http";
-  return "generic";
-}
-function foldDomainError(handlers) {
-  return (err) => {
-    switch (classifyDomainError(err)) {
-      case "validation":
-        return handlers.validation(err);
-      case "timeout":
-        return handlers.timeout(err);
-      case "http":
-        return handlers.http(err);
-      case "generic":
-        return handlers.generic(err);
-    }
-  };
-}
-function isPromiseLike(v) {
-  return v && typeof v.then === "function";
-}
-function createCamundaFpClient(options) {
-  const base = createCamundaClient(options);
-  const cache = /* @__PURE__ */ new Map();
-  function wrap(fn) {
-    return (...args) => async () => {
-      try {
-        const r = fn.apply(base, args);
-        const val = isPromiseLike(r) ? await r : r;
-        return right(val);
-      } catch (e) {
-        return left(toDomainError(e));
-      }
-    };
-  }
-  const handler = {
-    get(_t, prop) {
-      if (prop === "inner") return base;
-      if (cache.has(prop)) return cache.get(prop);
-      const value = base[prop];
-      if (typeof value === "function") {
-        const w = wrap(value);
-        cache.set(prop, w);
-        return w;
-      }
-      cache.set(prop, value);
-      return value;
-    }
-  };
-  return new Proxy({}, handler);
-}
-function retryTE(task, opts) {
-  const { max, baseDelayMs = 100, shouldRetry } = opts;
-  return async () => {
-    let attempt = 0;
-    let lastLeft;
-    while (attempt < max) {
-      const res = await task();
-      if (isRight(res)) return res;
-      lastLeft = res;
-      attempt++;
-      const retry = attempt < max && (shouldRetry ? await shouldRetry(res.left, attempt) : true);
-      if (!retry) return res;
-      const delay = Math.min(2e3, baseDelayMs * 2 ** (attempt - 1));
-      await new Promise((r) => setTimeout(r, delay));
-    }
-    return lastLeft;
-  };
-}
-function withTimeoutTE(task, ms, onTimeout) {
-  return async () => {
-    let settled = false;
-    const t = task().then((r) => {
-      settled = true;
-      return r;
-    });
-    const timeout = new Promise(
-      (res) => setTimeout(() => {
-        if (!settled)
-          res(left(onTimeout ? onTimeout() : new Error(`Timeout after ${ms}ms`)));
-      }, ms)
-    );
-    return Promise.race([t, timeout]);
-  };
-}
-function eventuallyTE(thunk, predicate, opts) {
-  const { intervalMs = 500, waitUpToMs } = opts;
-  return async () => {
-    const start = Date.now();
-    let attempt = 0;
-    while (true) {
-      attempt++;
-      try {
-        const val = await thunk();
-        if (await predicate(val)) return right(val);
-      } catch (e) {
-        return left(e);
-      }
-      const elapsed = Date.now() - start;
-      if (elapsed >= waitUpToMs)
-        return left(
-          new EventualConsistencyTimeoutError({ attempts: attempt, elapsedMs: elapsed })
-        );
-      await new Promise((r) => setTimeout(r, intervalMs));
-    }
-  };
-}
-
 export {
   isSdkError,
   CamundaValidationError,
@@ -20799,14 +20677,6 @@ export {
   JobActionReceipt,
   CancelError,
   createCamundaClient,
-  CamundaClient,
-  isLeft,
-  isRight,
-  classifyDomainError,
-  foldDomainError,
-  createCamundaFpClient,
-  retryTE,
-  withTimeoutTE,
-  eventuallyTE
+  CamundaClient
 };
-//# sourceMappingURL=chunk-SHE5T54L.js.map
+//# sourceMappingURL=chunk-WHBUDCPU.js.map