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

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

@@ -656,6 +656,85 @@ var JobWorker = class {
   }
 };
 
+// src/runtime/pagination.ts
+function abortError() {
+  const e = new Error("Pagination aborted");
+  e.name = "AbortError";
+  return e;
+}
+function limitOf(body) {
+  const l = body.page?.limit;
+  return typeof l === "number" ? l : void 0;
+}
+function advancePage(prev, advance) {
+  const rest = { ...prev ?? {} };
+  delete rest.after;
+  delete rest.from;
+  delete rest.before;
+  return { ...rest, ...advance };
+}
+function nextPageRequest(body, response, mode = "auto") {
+  const limit = limitOf(body);
+  const count = response.items.length;
+  if (count === 0) return null;
+  if (limit !== void 0 && count < limit) return null;
+  const endCursor = response.page?.endCursor ?? null;
+  const hasCursor = body.page?.after !== void 0 || body.page?.before !== void 0;
+  const hasFrom = typeof body.page?.from === "number";
+  let useCursor;
+  if (mode === "cursor") useCursor = true;
+  else if (mode === "offset") useCursor = false;
+  else if (hasCursor && !hasFrom) useCursor = true;
+  else if (hasFrom && !hasCursor) useCursor = false;
+  else useCursor = endCursor !== null;
+  if (useCursor) {
+    if (endCursor === null) return null;
+    if (body.page?.after === endCursor) return null;
+    return {
+      ...body,
+      page: advancePage(body.page, { after: endCursor })
+    };
+  }
+  const prevFrom = typeof body.page?.from === "number" ? body.page.from : 0;
+  return {
+    ...body,
+    page: advancePage(body.page, { from: prevFrom + count })
+  };
+}
+function paginate(fetchPage, body, opts = {}) {
+  const { signal, maxPages = Number.POSITIVE_INFINITY, mode = "auto" } = opts;
+  async function* pages() {
+    let current = body;
+    let fetched = 0;
+    while (true) {
+      if (fetched >= maxPages) return;
+      if (signal?.aborted) throw abortError();
+      const response = await fetchPage(current, signal, fetched === 0);
+      const next = nextPageRequest(current, response, mode);
+      yield response;
+      fetched += 1;
+      if (next === null) return;
+      current = next;
+    }
+  }
+  async function* items() {
+    for await (const page of pages()) {
+      yield* page.items;
+    }
+  }
+  async function toArray() {
+    const out = [];
+    for await (const item of items()) out.push(item);
+    return out;
+  }
+  return {
+    pages,
+    items,
+    toArray,
+    [Symbol.asyncIterator]: pages
+  };
+}
+
 // src/gen/core/serverSentEvents.gen.ts
 var __STANDARD_REQUEST_INIT_KEYS = [
   "method",
@@ -3450,6 +3529,59 @@ var resumeClusterExporting = (options) => (options?.client ?? client).post({
   url: "/cluster/v2/exporting/resume",
   ...options
 });
+var listRuntimeBackupsAsClusterAdmin = (options) => (options?.client ?? client).get({
+  requestValidator: void 0,
+  responseValidator: void 0,
+  security: [{ scheme: "bearer", type: "http" }, { scheme: "basic", type: "http" }],
+  url: "/cluster/v2/backups/runtime",
+  ...options
+});
+var takeRuntimeBackupAsClusterAdmin = (options) => (options?.client ?? client).post({
+  requestValidator: void 0,
+  responseValidator: void 0,
+  security: [{ scheme: "bearer", type: "http" }, { scheme: "basic", type: "http" }],
+  url: "/cluster/v2/backups/runtime",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options?.headers
+  }
+});
+var deleteRuntimeBackupStateAsClusterAdmin = (options) => (options?.client ?? client).delete({
+  requestValidator: void 0,
+  responseValidator: void 0,
+  security: [{ scheme: "bearer", type: "http" }, { scheme: "basic", type: "http" }],
+  url: "/cluster/v2/backups/runtime/state",
+  ...options
+});
+var getRuntimeBackupStateAsClusterAdmin = (options) => (options?.client ?? client).get({
+  requestValidator: void 0,
+  responseValidator: void 0,
+  security: [{ scheme: "bearer", type: "http" }, { scheme: "basic", type: "http" }],
+  url: "/cluster/v2/backups/runtime/state",
+  ...options
+});
+var syncRuntimeBackupStateAsClusterAdmin = (options) => (options?.client ?? client).post({
+  requestValidator: void 0,
+  responseValidator: void 0,
+  security: [{ scheme: "bearer", type: "http" }, { scheme: "basic", type: "http" }],
+  url: "/cluster/v2/backups/runtime/state/sync",
+  ...options
+});
+var deleteRuntimeBackupAsClusterAdmin = (options) => (options.client ?? client).delete({
+  requestValidator: void 0,
+  responseValidator: void 0,
+  security: [{ scheme: "bearer", type: "http" }, { scheme: "basic", type: "http" }],
+  url: "/cluster/v2/backups/runtime/{backupId}",
+  ...options
+});
+var getRuntimeBackupAsClusterAdmin = (options) => (options.client ?? client).get({
+  requestValidator: void 0,
+  responseValidator: void 0,
+  security: [{ scheme: "bearer", type: "http" }, { scheme: "basic", type: "http" }],
+  url: "/cluster/v2/backups/runtime/{backupId}",
+  ...options
+});
 var listHistoryBackupsAsClusterAdmin = (options) => (options?.client ?? client).get({
   requestValidator: void 0,
   responseValidator: void 0,
@@ -5027,7 +5159,7 @@ function installAuthInterceptor(client2, getStrategy, getAuthHeaders) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.32";
+var packageVersion = "10.0.0-alpha.34";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -6732,6 +6864,70 @@ function evaluateSdkResponse(raw, opts) {
   return raw.data !== void 0 ? raw.data : raw;
 }
 
+// src/runtime/searchPagination.ts
+var NON_PAGINATED_SEARCH_METHODS = /* @__PURE__ */ new Set(["searchVariablesAsDto"]);
+function mergeAbortSignals(outer, inner) {
+  if (!inner) return outer;
+  const anyFn = AbortSignal.any;
+  if (typeof anyFn === "function") return anyFn([outer, inner]);
+  const ac = new AbortController();
+  if (outer.aborted || inner.aborted) {
+    ac.abort();
+    return ac.signal;
+  }
+  const onAbort = () => ac.abort();
+  outer.addEventListener("abort", onAbort, { once: true });
+  inner.addEventListener("abort", onAbort, { once: true });
+  return ac.signal;
+}
+function installSearchPagination(client2) {
+  const seen = /* @__PURE__ */ new Set();
+  let proto = Object.getPrototypeOf(client2);
+  while (proto && proto !== Object.prototype) {
+    for (const name of Object.getOwnPropertyNames(proto)) {
+      if (seen.has(name)) continue;
+      if (!/^search[A-Z]/.test(name)) continue;
+      if (NON_PAGINATED_SEARCH_METHODS.has(name)) continue;
+      const method = proto[name];
+      if (typeof method !== "function") continue;
+      seen.add(name);
+      const call = method.bind(client2);
+      const wrapper = ((...args) => call(...args));
+      wrapper.paginate = (body, opts = {}) => {
+        const { consistency, ...pageOpts } = opts;
+        const fetchPage = (b, signal, isFirstPage = false) => {
+          const baseConsistency = isFirstPage ? consistency ?? { waitUpToMs: 0 } : { waitUpToMs: 0 };
+          const consistencyValue = signal ? {
+            ...baseConsistency,
+            abortSignal: mergeAbortSignals(
+              signal,
+              baseConsistency.abortSignal
+            )
+          } : baseConsistency;
+          const consistencyArg = { consistency: consistencyValue };
+          const p = call(b, consistencyArg);
+          if (signal) {
+            const onAbort = () => p.cancel?.();
+            signal.addEventListener("abort", onAbort, { once: true });
+            const cleanup = () => signal.removeEventListener("abort", onAbort);
+            p.then(cleanup, cleanup);
+            if (signal.aborted) p.cancel?.();
+          }
+          return p;
+        };
+        return paginate(fetchPage, body, pageOpts);
+      };
+      Object.defineProperty(client2, name, {
+        value: wrapper,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+}
+
 // src/gen/CamundaClient.ts
 function deepFreeze2(obj) {
   if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
@@ -6742,7 +6938,7 @@ function deepFreeze2(obj) {
   }
   return obj;
 }
-var VOID_RESPONSES = /* @__PURE__ */ new Set(["zDeleteAuthorizationResponse", "zUpdateAuthorizationResponse", "zDeleteRuntimeBackupStateResponse", "zDeleteRuntimeBackupResponse", "zDeleteHistoryBackupResponse", "zCancelBatchOperationResponse", "zResumeBatchOperationResponse", "zSuspendBatchOperationResponse", "zPinClockResponse", "zResetClockResponse", "zDeleteGlobalClusterVariableResponse", "zDeleteTenantClusterVariableResponse", "zDeleteDecisionInstanceResponse", "zDeleteDocumentResponse", "zActivateAdHocSubProcessActivitiesResponse", "zCreateElementInstanceVariablesResponse", "zPauseExportingResponse", "zResumeExportingResponse", "zDeleteGlobalTaskListenerResponse", "zDeleteGroupResponse", "zUnassignClientFromGroupResponse", "zAssignClientToGroupResponse", "zUnassignMappingRuleFromGroupResponse", "zAssignMappingRuleToGroupResponse", "zUnassignUserFromGroupResponse", "zAssignUserToGroupResponse", "zResolveIncidentResponse", "zUpdateJobResponse", "zCompleteJobResponse", "zThrowJobErrorResponse", "zFailJobResponse", "zDeleteMappingRuleResponse", "zAssignProcessInstanceBusinessIdResponse", "zCancelProcessInstanceResponse", "zDeleteProcessInstanceResponse", "zMigrateProcessInstanceResponse", "zModifyProcessInstanceResponse", "zResumeProcessInstanceResponse", "zSuspendProcessInstanceResponse", "zDeleteRoleResponse", "zUnassignRoleFromClientResponse", "zAssignRoleToClientResponse", "zUnassignRoleFromGroupResponse", "zAssignRoleToGroupResponse", "zUnassignRoleFromMappingRuleResponse", "zAssignRoleToMappingRuleResponse", "zUnassignRoleFromUserResponse", "zAssignRoleToUserResponse", "zGetStatusResponse", "zDeleteTenantResponse", "zUnassignClientFromTenantResponse", "zAssignClientToTenantResponse", "zUnassignGroupFromTenantResponse", "zAssignGroupToTenantResponse", "zUnassignMappingRuleFromTenantResponse", "zAssignMappingRuleToTenantResponse", "zUnassignRoleFromTenantResponse", "zAssignRoleToTenantResponse", "zUnassignUserFromTenantResponse", "zAssignUserToTenantResponse", "zPauseClusterExportingResponse", "zResumeClusterExportingResponse", "zDeleteHistoryBackupAsClusterAdminResponse", "zDeleteUserResponse", "zUpdateUserTaskResponse", "zUnassignUserTaskResponse", "zAssignUserTaskResponse", "zCompleteUserTaskResponse"]);
+var VOID_RESPONSES = /* @__PURE__ */ new Set(["zDeleteAuthorizationResponse", "zUpdateAuthorizationResponse", "zDeleteRuntimeBackupStateResponse", "zDeleteRuntimeBackupResponse", "zDeleteHistoryBackupResponse", "zCancelBatchOperationResponse", "zResumeBatchOperationResponse", "zSuspendBatchOperationResponse", "zPinClockResponse", "zResetClockResponse", "zDeleteGlobalClusterVariableResponse", "zDeleteTenantClusterVariableResponse", "zDeleteDecisionInstanceResponse", "zDeleteDocumentResponse", "zActivateAdHocSubProcessActivitiesResponse", "zCreateElementInstanceVariablesResponse", "zPauseExportingResponse", "zResumeExportingResponse", "zDeleteGlobalTaskListenerResponse", "zDeleteGroupResponse", "zUnassignClientFromGroupResponse", "zAssignClientToGroupResponse", "zUnassignMappingRuleFromGroupResponse", "zAssignMappingRuleToGroupResponse", "zUnassignUserFromGroupResponse", "zAssignUserToGroupResponse", "zResolveIncidentResponse", "zUpdateJobResponse", "zCompleteJobResponse", "zThrowJobErrorResponse", "zFailJobResponse", "zDeleteMappingRuleResponse", "zAssignProcessInstanceBusinessIdResponse", "zCancelProcessInstanceResponse", "zDeleteProcessInstanceResponse", "zMigrateProcessInstanceResponse", "zModifyProcessInstanceResponse", "zResumeProcessInstanceResponse", "zSuspendProcessInstanceResponse", "zDeleteRoleResponse", "zUnassignRoleFromClientResponse", "zAssignRoleToClientResponse", "zUnassignRoleFromGroupResponse", "zAssignRoleToGroupResponse", "zUnassignRoleFromMappingRuleResponse", "zAssignRoleToMappingRuleResponse", "zUnassignRoleFromUserResponse", "zAssignRoleToUserResponse", "zGetStatusResponse", "zDeleteTenantResponse", "zUnassignClientFromTenantResponse", "zAssignClientToTenantResponse", "zUnassignGroupFromTenantResponse", "zAssignGroupToTenantResponse", "zUnassignMappingRuleFromTenantResponse", "zAssignMappingRuleToTenantResponse", "zUnassignRoleFromTenantResponse", "zAssignRoleToTenantResponse", "zUnassignUserFromTenantResponse", "zAssignUserToTenantResponse", "zPauseClusterExportingResponse", "zResumeClusterExportingResponse", "zDeleteRuntimeBackupStateAsClusterAdminResponse", "zDeleteRuntimeBackupAsClusterAdminResponse", "zDeleteHistoryBackupAsClusterAdminResponse", "zDeleteUserResponse", "zUpdateUserTaskResponse", "zUnassignUserTaskResponse", "zAssignUserTaskResponse", "zCompleteUserTaskResponse"]);
 var CancelError = class extends Error {
   constructor() {
     super("Cancelled");
@@ -6782,7 +6978,7 @@ function toCancelable2(factory) {
 function createCamundaClient(options) {
   return new CamundaClient(options);
 }
-var CamundaClient = class {
+var CamundaClientBase = class {
   _client;
   _config;
   _auth = createAuthFacade({
@@ -6909,6 +7105,7 @@ var CamundaClient = class {
         return ["config.hydrated"];
       }
     });
+    installSearchPagination(this);
   }
   get config() {
     return this._config;
@@ -7046,7 +7243,7 @@ var CamundaClient = class {
   _schemasPromise = null;
   _loadSchemas() {
     if (!this._schemasPromise) {
-      this._schemasPromise = import("./zod.gen-2LVIU5XR.js");
+      this._schemasPromise = import("./zod.gen-GHFW5D76.js");
     }
     return this._schemasPromise;
   }
@@ -10407,6 +10604,66 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "deleteRuntimeBackup", exempt: false, retryOverride: options?.retry });
     });
   }
+  deleteRuntimeBackupAsClusterAdmin(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { backupId, physicalTenantId } = arg || {};
+      let envelope = {};
+      envelope.path = { backupId };
+      envelope.query = { physicalTenantId };
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        if (envelope.path !== void 0) {
+          const maybePath = await this._validation.gateRequest("deleteRuntimeBackupAsClusterAdmin", _schemas.zDeleteRuntimeBackupAsClusterAdminPath, envelope.path);
+          if (this._validation.settings.req === "strict") envelope.path = maybePath;
+        }
+        if (envelope.query !== void 0) {
+          const maybeQuery = await this._validation.gateRequest("deleteRuntimeBackupAsClusterAdmin", _schemas.zDeleteRuntimeBackupAsClusterAdminQuery, envelope.query);
+          if (this._validation.settings.req === "strict") envelope.query = maybeQuery;
+        }
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.path) opts.path = envelope.path;
+      if (envelope.query) opts.query = envelope.query;
+      const call = async () => {
+        try {
+          const _raw = await deleteRuntimeBackupAsClusterAdmin(opts);
+          let data = this._evaluateResponse(_raw, "deleteRuntimeBackupAsClusterAdmin", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zDeleteRuntimeBackupAsClusterAdminResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zDeleteRuntimeBackupAsClusterAdminResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("deleteRuntimeBackupAsClusterAdmin", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "deleteRuntimeBackupAsClusterAdmin", exempt: false, retryOverride: options?.retry });
+    });
+  }
   deleteRuntimeBackupState(arg, options) {
     return toCancelable2(async (signal) => {
       const opts = { client: this._client, signal, throwOnError: false };
@@ -10450,6 +10707,60 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "deleteRuntimeBackupState", exempt: false, retryOverride: options?.retry });
     });
   }
+  deleteRuntimeBackupStateAsClusterAdmin(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { physicalTenantId } = arg || {};
+      let envelope = {};
+      envelope.query = { physicalTenantId };
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        if (envelope.query !== void 0) {
+          const maybeQuery = await this._validation.gateRequest("deleteRuntimeBackupStateAsClusterAdmin", _schemas.zDeleteRuntimeBackupStateAsClusterAdminQuery, envelope.query);
+          if (this._validation.settings.req === "strict") envelope.query = maybeQuery;
+        }
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.query) opts.query = envelope.query;
+      const call = async () => {
+        try {
+          const _raw = await deleteRuntimeBackupStateAsClusterAdmin(opts);
+          let data = this._evaluateResponse(_raw, "deleteRuntimeBackupStateAsClusterAdmin", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zDeleteRuntimeBackupStateAsClusterAdminResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zDeleteRuntimeBackupStateAsClusterAdminResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("deleteRuntimeBackupStateAsClusterAdmin", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "deleteRuntimeBackupStateAsClusterAdmin", exempt: false, retryOverride: options?.retry });
+    });
+  }
   deleteTenant(arg, options) {
     return toCancelable2(async (signal) => {
       const { tenantId } = arg || {};
@@ -13643,6 +13954,66 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "getRuntimeBackup", exempt: false, retryOverride: options?.retry });
     });
   }
+  getRuntimeBackupAsClusterAdmin(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { backupId, physicalTenantId } = arg || {};
+      let envelope = {};
+      envelope.path = { backupId };
+      envelope.query = { physicalTenantId };
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        if (envelope.path !== void 0) {
+          const maybePath = await this._validation.gateRequest("getRuntimeBackupAsClusterAdmin", _schemas.zGetRuntimeBackupAsClusterAdminPath, envelope.path);
+          if (this._validation.settings.req === "strict") envelope.path = maybePath;
+        }
+        if (envelope.query !== void 0) {
+          const maybeQuery = await this._validation.gateRequest("getRuntimeBackupAsClusterAdmin", _schemas.zGetRuntimeBackupAsClusterAdminQuery, envelope.query);
+          if (this._validation.settings.req === "strict") envelope.query = maybeQuery;
+        }
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.path) opts.path = envelope.path;
+      if (envelope.query) opts.query = envelope.query;
+      const call = async () => {
+        try {
+          const _raw = await getRuntimeBackupAsClusterAdmin(opts);
+          let data = this._evaluateResponse(_raw, "getRuntimeBackupAsClusterAdmin", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zGetRuntimeBackupAsClusterAdminResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zGetRuntimeBackupAsClusterAdminResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("getRuntimeBackupAsClusterAdmin", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "getRuntimeBackupAsClusterAdmin", exempt: false, retryOverride: options?.retry });
+    });
+  }
   getRuntimeBackupState(arg, options) {
     return toCancelable2(async (signal) => {
       const opts = { client: this._client, signal, throwOnError: false };
@@ -13686,6 +14057,60 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "getRuntimeBackupState", exempt: false, retryOverride: options?.retry });
     });
   }
+  getRuntimeBackupStateAsClusterAdmin(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { physicalTenantId } = arg || {};
+      let envelope = {};
+      envelope.query = { physicalTenantId };
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        if (envelope.query !== void 0) {
+          const maybeQuery = await this._validation.gateRequest("getRuntimeBackupStateAsClusterAdmin", _schemas.zGetRuntimeBackupStateAsClusterAdminQuery, envelope.query);
+          if (this._validation.settings.req === "strict") envelope.query = maybeQuery;
+        }
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.query) opts.query = envelope.query;
+      const call = async () => {
+        try {
+          const _raw = await getRuntimeBackupStateAsClusterAdmin(opts);
+          let data = this._evaluateResponse(_raw, "getRuntimeBackupStateAsClusterAdmin", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zGetRuntimeBackupStateAsClusterAdminResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zGetRuntimeBackupStateAsClusterAdminResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("getRuntimeBackupStateAsClusterAdmin", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "getRuntimeBackupStateAsClusterAdmin", exempt: false, retryOverride: options?.retry });
+    });
+  }
   getStartProcessForm(arg, consistencyManagement, options) {
     if (!consistencyManagement) throw new Error("Missing consistencyManagement parameter for eventually consistent endpoint");
     const useConsistency = consistencyManagement.consistency;
@@ -14441,6 +14866,60 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "listRuntimeBackups", exempt: false, retryOverride: options?.retry });
     });
   }
+  listRuntimeBackupsAsClusterAdmin(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { physicalTenantId, prefix } = arg || {};
+      let envelope = {};
+      envelope.query = { physicalTenantId, prefix };
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        if (envelope.query !== void 0) {
+          const maybeQuery = await this._validation.gateRequest("listRuntimeBackupsAsClusterAdmin", _schemas.zListRuntimeBackupsAsClusterAdminQuery, envelope.query);
+          if (this._validation.settings.req === "strict") envelope.query = maybeQuery;
+        }
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.query) opts.query = envelope.query;
+      const call = async () => {
+        try {
+          const _raw = await listRuntimeBackupsAsClusterAdmin(opts);
+          let data = this._evaluateResponse(_raw, "listRuntimeBackupsAsClusterAdmin", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zListRuntimeBackupsAsClusterAdminResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zListRuntimeBackupsAsClusterAdminResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("listRuntimeBackupsAsClusterAdmin", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "listRuntimeBackupsAsClusterAdmin", exempt: false, retryOverride: options?.retry });
+    });
+  }
   listSecrets(arg, options) {
     return toCancelable2(async (signal) => {
       const _body = arg;
@@ -18733,6 +19212,60 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "syncRuntimeBackupState", exempt: false, retryOverride: options?.retry });
     });
   }
+  syncRuntimeBackupStateAsClusterAdmin(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { physicalTenantId } = arg || {};
+      let envelope = {};
+      envelope.query = { physicalTenantId };
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        if (envelope.query !== void 0) {
+          const maybeQuery = await this._validation.gateRequest("syncRuntimeBackupStateAsClusterAdmin", _schemas.zSyncRuntimeBackupStateAsClusterAdminQuery, envelope.query);
+          if (this._validation.settings.req === "strict") envelope.query = maybeQuery;
+        }
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.query) opts.query = envelope.query;
+      const call = async () => {
+        try {
+          const _raw = await syncRuntimeBackupStateAsClusterAdmin(opts);
+          let data = this._evaluateResponse(_raw, "syncRuntimeBackupStateAsClusterAdmin", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zSyncRuntimeBackupStateAsClusterAdminResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zSyncRuntimeBackupStateAsClusterAdminResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("syncRuntimeBackupStateAsClusterAdmin", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "syncRuntimeBackupStateAsClusterAdmin", exempt: false, retryOverride: options?.retry });
+    });
+  }
   takeHistoryBackup(arg, options) {
     return toCancelable2(async (signal) => {
       const _body = arg;
@@ -18901,6 +19434,66 @@ var CamundaClient = class {
       return this._invokeWithRetry(() => call(), { opId: "takeRuntimeBackup", exempt: false, retryOverride: options?.retry });
     });
   }
+  takeRuntimeBackupAsClusterAdmin(arg, options) {
+    return toCancelable2(async (signal) => {
+      const { physicalTenantId, ..._body } = arg || {};
+      let envelope = {};
+      envelope.query = { physicalTenantId };
+      envelope.body = _body;
+      if (this._validation.settings.req !== "none") {
+        const _schemas = await this._loadSchemas();
+        if (envelope.body !== void 0) {
+          const maybeBody = await this._validation.gateRequest("takeRuntimeBackupAsClusterAdmin", _schemas.zTakeRuntimeBackupAsClusterAdminBody, envelope.body);
+          if (this._validation.settings.req === "strict") envelope.body = maybeBody;
+        }
+        if (envelope.query !== void 0) {
+          const maybeQuery = await this._validation.gateRequest("takeRuntimeBackupAsClusterAdmin", _schemas.zTakeRuntimeBackupAsClusterAdminQuery, envelope.query);
+          if (this._validation.settings.req === "strict") envelope.query = maybeQuery;
+        }
+      }
+      const opts = { client: this._client, signal, throwOnError: false };
+      if (envelope.query) opts.query = envelope.query;
+      if (envelope.body !== void 0) opts.body = envelope.body;
+      const call = async () => {
+        try {
+          const _raw = await takeRuntimeBackupAsClusterAdmin(opts);
+          let data = this._evaluateResponse(_raw, "takeRuntimeBackupAsClusterAdmin", (resp) => {
+            const st = resp.status ?? resp.response?.status;
+            if (!st) return void 0;
+            const candidate = st === 429 || st === 503 || st === 500;
+            if (!candidate) return void 0;
+            let prob = void 0;
+            if (resp.error && typeof resp.error === "object") prob = resp.error;
+            const err = new Error(prob && (prob.title || prob.detail) ? prob.title || prob.detail : "HTTP " + st);
+            err.status = st;
+            err.name = "HttpSdkError";
+            if (prob) {
+              for (const k of ["type", "title", "detail", "instance"]) if (prob[k] !== void 0) err[k] = prob[k];
+            }
+            const isBp = st === 429 || st === 503 && err.title === "RESOURCE_EXHAUSTED" || st === 500 && (typeof err.detail === "string" && /RESOURCE_EXHAUSTED/.test(err.detail));
+            if (!isBp) err.nonRetryable = true;
+            return err;
+          });
+          const _respSchemaName = "zTakeRuntimeBackupAsClusterAdminResponse";
+          if (this._isVoidResponse(_respSchemaName)) {
+            data = void 0;
+          }
+          if (this._validation.settings.res !== "none") {
+            const _schemas = await this._loadSchemas();
+            const _schema = _schemas.zTakeRuntimeBackupAsClusterAdminResponse;
+            if (_schema) {
+              const maybeR = await this._validation.gateResponse("takeRuntimeBackupAsClusterAdmin", _schema, data);
+              if (this._validation.settings.res === "strict") data = maybeR;
+            }
+          }
+          return data;
+        } catch (e) {
+          throw e;
+        }
+      };
+      return this._invokeWithRetry(() => call(), { opId: "takeRuntimeBackupAsClusterAdmin", exempt: false, retryOverride: options?.retry });
+    });
+  }
   throwJobError(arg, options) {
     return toCancelable2(async (signal) => {
       const { jobKey, ..._body } = arg || {};
@@ -20662,6 +21255,7 @@ var CamundaClient = class {
     });
   }
 };
+var CamundaClient = CamundaClientBase;
 
 export {
   isSdkError,
@@ -20675,8 +21269,10 @@ export {
   VariableCollector,
   collectTypedVariables,
   JobActionReceipt,
+  nextPageRequest,
+  paginate,
   CancelError,
   createCamundaClient,
   CamundaClient
 };
-//# sourceMappingURL=chunk-WHBUDCPU.js.map
+//# sourceMappingURL=chunk-DVCU3RZY.js.map