@camunda8/orchestration-cluster-api 10.0.0-alpha.52 → 10.0.0-alpha.53

package/dist/chunk-PBBQC3SA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runtime/pagination.ts","../src/runtime/typedVariables.ts","../src/runtime/searchPagination.ts","../src/runtime/threadedJobWorker.ts","../src/runtime/clientProxy.ts","../src/runtime/threadPool.ts","../src/gen/CamundaClient.ts"],"sourcesContent":["/*\n * Async-generator pagination engine for `search*` operations (issue #3).\n *\n * A single, shared runtime that turns any Orchestration Cluster `search*`\n * operation into a lazy, cancelable async stream — instead of hand-writing\n * next-page bookkeeping on 46 endpoints. This module is the pure core (no\n * dependency on generated types or the client); `searchPagination.ts` binds it\n * onto the generated client so every search method gains a `.paginate(...)`.\n */\n\n/** The `page` object every search response carries (structural subset). */\nexport interface SearchPageResponse {\n  totalItems: number;\n  hasMoreTotalItems: boolean;\n  startCursor: string | null;\n  endCursor: string | null;\n}\n\n/** Any search response: an `items` array plus the `page` cursor block. */\nexport interface SearchResponse<TItem> {\n  items: TItem[];\n  page: SearchPageResponse;\n}\n\n/** The `page` field of a search request body (cursor-forward or offset). */\nexport interface SearchPageRequest {\n  /** Cursor-forward: `endCursor` of the previous page. */\n  after?: string;\n  /** Cursor-backward: `startCursor` of the previous page (mutually exclusive with `after`/`from`). */\n  before?: string;\n  /** Offset: index to start from. */\n  from?: number;\n  limit?: number;\n  [k: string]: unknown;\n}\n\n/** A request body that optionally carries a `page` block. */\nexport type SearchBody = { page?: SearchPageRequest } & Record<string, unknown>;\n\nexport type PaginationMode = 'auto' | 'cursor' | 'offset';\n\nexport interface PaginateOptions {\n  /** Abort between pages; a fired signal stops further fetches. */\n  signal?: AbortSignal;\n  /**\n   * Safety cap on pages fetched (default: unbounded). A non-positive value\n   * (`0` or negative) fetches no pages at all — the cap is enforced *before*\n   * the first request, so it is always honoured exactly.\n   */\n  maxPages?: number;\n  /** How to advance. `auto` prefers a cursor, falls back to offset. */\n  mode?: PaginationMode;\n}\n\n/**\n * Fetches one page for a given body. Decoupled from the facade's `ec` arg.\n *\n * `isFirstPage` is `true` only for the initial fetch of *this* iteration run\n * (each `pages()`/`items()`/`toArray()` call starts a fresh run). Adapters that\n * carry per-first-page state (e.g. an eventual-consistency window) must key off\n * this flag rather than closure state so that reusing a paginator, or consuming\n * two views concurrently, does not leak first-page behaviour across iterators.\n */\nexport type FetchPage<TItem, TBody extends SearchBody> = (\n  body: TBody,\n  signal?: AbortSignal,\n  isFirstPage?: boolean\n) => Promise<SearchResponse<TItem>>;\n\nexport interface Paginator<TItem> extends AsyncIterable<SearchResponse<TItem>> {\n  /** Yields whole pages, fetching each lazily as it is consumed. */\n  pages(): AsyncGenerator<SearchResponse<TItem>, void, void>;\n  /** Yields individual items across all pages (`yield*`-flattened). */\n  items(): AsyncGenerator<TItem, void, void>;\n  /** Eagerly drains every item into an array. Bounded result sets only. */\n  toArray(): Promise<TItem[]>;\n}\n\nfunction abortError(): Error {\n  const e = new Error('Pagination aborted');\n  e.name = 'AbortError';\n  return e;\n}\n\nfunction limitOf(body: SearchBody): number | undefined {\n  const l = body.page?.limit;\n  return typeof l === 'number' ? l : undefined;\n}\n\n/**\n * Build the next `page` block, keeping caller fields (e.g. `limit`) but dropping\n * pagination fields incompatible with the mode we're advancing in. The server's\n * `SearchQueryPageRequest` contract forbids mixing offset (`from`) and cursor\n * (`after`/`before`) fields, so we strip the ones that don't belong before\n * adding our own — otherwise spreading the previous `page` would leak an\n * offset/backward field into a forward-cursor request (or vice versa).\n */\nfunction advancePage(\n  prev: SearchPageRequest | undefined,\n  advance: { after: string } | { from: number }\n): SearchPageRequest {\n  const rest: SearchPageRequest = { ...(prev ?? {}) };\n  delete rest.after;\n  delete rest.from;\n  delete rest.before;\n  return { ...rest, ...advance };\n}\n\n/**\n * Compute the next request body from the previous body + response, or `null`\n * when no further page exists. Pure — the async generator is built on top of it.\n */\nexport function nextPageRequest<TItem, TBody extends SearchBody>(\n  body: TBody,\n  response: SearchResponse<TItem>,\n  mode: PaginationMode = 'auto'\n): TBody | null {\n  const limit = limitOf(body);\n  const count = response.items.length;\n\n  // No items at all → definitely nothing after this.\n  if (count === 0) return null;\n  // A short page (fewer than requested) means we've reached the end.\n  if (limit !== undefined && count < limit) return null;\n\n  const endCursor = response.page?.endCursor ?? null;\n\n  // Decide cursor vs offset. In `auto` mode, pin the choice to the pagination\n  // style the *request* already uses whenever it uses exactly one: a request\n  // carrying only `after`/`before` is cursor pagination and must NOT fall back to\n  // an offset (`from`) request just because a full page returned\n  // `endCursor: null`; a request carrying only `from` is offset pagination and\n  // must NOT flip to a cursor request just because a response happened to include\n  // an `endCursor`. Either flip would mix mutually-exclusive fields, which the\n  // server's `SearchQueryPageRequest` contract forbids. When the request pins\n  // neither style (typically the first page) — or, pathologically, carries both —\n  // fall back to response cursor presence.\n  const hasCursor = body.page?.after !== undefined || body.page?.before !== undefined;\n  const hasFrom = typeof body.page?.from === 'number';\n  let useCursor: boolean;\n  if (mode === 'cursor') useCursor = true;\n  else if (mode === 'offset') useCursor = false;\n  else if (hasCursor && !hasFrom) useCursor = true;\n  else if (hasFrom && !hasCursor) useCursor = false;\n  else useCursor = endCursor !== null;\n\n  if (useCursor) {\n    if (endCursor === null) return null;\n    // No-progress guard: a server echoing the same cursor must not loop forever.\n    if (body.page?.after === endCursor) return null;\n    return {\n      ...body,\n      page: advancePage(body.page, { after: endCursor }),\n    } as TBody;\n  }\n\n  // Offset mode: advance `from` by however many items we actually received.\n  const prevFrom = typeof body.page?.from === 'number' ? body.page.from : 0;\n  return {\n    ...body,\n    page: advancePage(body.page, { from: prevFrom + count }),\n  } as TBody;\n}\n\n/**\n * Wrap a search operation as a lazy, cancelable async stream.\n *\n * @example\n *   const p = paginate((b, s) => searchProcessInstances(b, { ... }), body);\n *   for await (const pi of p.items()) { ... }        // item-by-item\n *   for await (const page of p.pages()) { ... }       // page-by-page\n */\nexport function paginate<TItem, TBody extends SearchBody>(\n  fetchPage: FetchPage<TItem, TBody>,\n  body: TBody,\n  opts: PaginateOptions = {}\n): Paginator<TItem> {\n  const { signal, maxPages = Number.POSITIVE_INFINITY, mode = 'auto' } = opts;\n\n  async function* pages(): AsyncGenerator<SearchResponse<TItem>, void, void> {\n    let current: TBody = body;\n    let fetched = 0;\n\n    while (true) {\n      // Enforce the page cap *before* fetching so a non-positive `maxPages`\n      // (0 or negative) fetches nothing, and a positive cap is never exceeded.\n      if (fetched >= maxPages) return;\n      if (signal?.aborted) throw abortError();\n\n      const response = await fetchPage(current, signal, fetched === 0);\n      // Compute the next request BEFORE yielding. A page consumer that mutates\n      // the yielded `response.items` (e.g. clears or splices it) while it holds\n      // the page must not be able to shorten `count` or otherwise alter the\n      // cursor/offset we derive for traversal — generated `items` arrays are\n      // ordinary mutable arrays, so snapshot our traversal decision first.\n      const next = nextPageRequest(current, response, mode);\n      yield response;\n      fetched += 1;\n\n      if (next === null) return;\n      current = next;\n    }\n  }\n\n  async function* items(): AsyncGenerator<TItem, void, void> {\n    for await (const page of pages()) {\n      yield* page.items;\n    }\n  }\n\n  async function toArray(): Promise<TItem[]> {\n    const out: TItem[] = [];\n    for await (const item of items()) out.push(item);\n    return out;\n  }\n\n  return {\n    pages,\n    items,\n    toArray,\n    [Symbol.asyncIterator]: pages,\n  };\n}\n","// Pure (I/O-free) core of the DTO-driven typed variable map feature.\n//\n// A Zod object schema is the DTO: its keys are the exact wire variable names to query for, and\n// its field shape drives validation. This mirrors the C# (reflection) and Python (Pydantic)\n// SDKs while staying idiomatic to TypeScript — the SDK already depends on Zod for request and\n// response validation.\n//\n// Keeping the paging collapse, scope-collision detection, and value deserialization free of HTTP\n// makes the memory-bound behaviour directly unit-testable. The HTTP wiring lives in the client\n// method `searchVariablesAsDto`, which injects a `fetchPage` callback.\nimport type { z } from 'zod';\nimport { liveClock } from './clock';\n\n/** Base class for all typed-variable errors, so callers can catch the whole family. */\nexport class TypedVariablesError extends Error {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super(message, options);\n    this.name = 'TypedVariablesError';\n  }\n}\n\n/**\n * Raised when a declared variable name is observed at more than one scope (for example a local\n * variable shadowing a process-level variable). The result would be ambiguous, so the search\n * fails loudly rather than silently picking one. Pass an explicit `scopeKey` to disambiguate.\n */\nexport class VariableScopeCollisionError extends TypedVariablesError {\n  constructor(\n    public readonly variableName: string,\n    public readonly scopeKeys: readonly string[]\n  ) {\n    super(\n      `Variable '${variableName}' was found at more than one scope (${scopeKeys.join(\n        ', '\n      )}). Pass an explicit scopeKey to disambiguate.`\n    );\n    this.name = 'VariableScopeCollisionError';\n  }\n}\n\n/** Raised when a variable's serialized value is not valid JSON. */\nexport class VariableDeserializationError extends TypedVariablesError {\n  constructor(\n    public readonly variableName: string,\n    options?: { cause?: unknown }\n  ) {\n    super(`Variable '${variableName}' could not be deserialized from its JSON value.`, options);\n    this.name = 'VariableDeserializationError';\n  }\n}\n\n/** A single variable item from a search page (the subset the collector needs). */\nexport interface TypedVariableItem {\n  name: string;\n  /** The variable value, serialized as JSON (the wire representation). */\n  value: string;\n  /** The scope key the variable is directly defined in. */\n  scopeKey: string;\n}\n\n/** One page of variable search results. */\nexport interface TypedVariablePage {\n  items: readonly TypedVariableItem[];\n  /** Cursor for the next page, or `null` when there are no more pages. */\n  endCursor: string | null;\n}\n\n/** Any Zod object schema; used as the DTO that declares the variables to fetch. */\nexport type AnyVariableSchema = z.ZodObject<any>;\n\n/**\n * The declared variable names, in declaration order. These key the `name $in [...]` filter.\n *\n * Guards against non-schema inputs (e.g. a JS caller, or an `any` cast) so the failure is a clear,\n * actionable error rather than an opaque `Cannot read properties of undefined` deep in paging.\n */\nexport function variableNamesFromSchema(schema: AnyVariableSchema): string[] {\n  const shape = schema == null ? undefined : schema.shape;\n  if (shape == null || typeof shape !== 'object') {\n    throw new TypedVariablesError(\n      'A Zod object schema is required: its keys declare the variable names to fetch.'\n    );\n  }\n  return Object.keys(shape);\n}\n\n/**\n * Result of a DTO-driven variable search.\n *\n * Holds the parsed variable values keyed by their declared name. Provides lenient, defensive\n * access via {@link has} / {@link get}, and a strict {@link validate} that parses the values\n * against the schema — returning a fully-typed object or throwing a `ZodError` when a required\n * variable is missing or malformed.\n */\nexport class VariableMap<TSchema extends AnyVariableSchema> {\n  constructor(\n    private readonly _raw: Readonly<Record<string, unknown>>,\n    private readonly _schema: TSchema\n  ) {}\n\n  /** The parsed variable values, keyed by variable name. */\n  get raw(): Readonly<Record<string, unknown>> {\n    return this._raw;\n  }\n\n  /** Whether a variable with the given name is present in the result. */\n  has(variableName: keyof z.input<TSchema> & string): boolean;\n  has(variableName: string): boolean;\n  has(variableName: string): boolean {\n    return Object.hasOwn(this._raw, variableName);\n  }\n\n  /**\n   * Lenient access. Returns the JSON-parsed wire value, or `undefined` when the variable is absent.\n   *\n   * The value is *not* run through the schema, so a declared key is narrowed to that field's schema\n   * *input* type (`z.input`) unioned with `undefined` — not the post-validation output type. This\n   * keeps the type honest for schemas with transforms or effects, where the parsed wire value can\n   * differ from `validate()`'s output. Any other key resolves to `undefined`: the result only ever\n   * holds the declared variable names, so an undeclared key can never carry a value.\n   */\n  get<K extends string>(\n    variableName: K\n  ): K extends keyof z.input<TSchema> ? z.input<TSchema>[K] | undefined : undefined;\n  get(variableName: string): unknown {\n    return this.has(variableName) ? this._raw[variableName] : undefined;\n  }\n\n  /**\n   * Strict access. Parses the collected values against the schema and returns the typed object.\n   * Required variables must be present and well-formed, otherwise a `ZodError` is thrown.\n   */\n  validate(): z.infer<TSchema> {\n    return this._schema.parse(this._raw);\n  }\n}\n\nfunction parseValue(variableName: string, value: string): unknown {\n  try {\n    return JSON.parse(value);\n  } catch (cause) {\n    throw new VariableDeserializationError(variableName, { cause });\n  }\n}\n\n/**\n * Incrementally collapses paged variable items into a parsed name-to-value map.\n *\n * Memory stays bounded by the DTO shape rather than the total number of paged items: only the\n * first value seen per requested name is retained, alongside the set of scope keys observed for\n * that name (used for collision detection). Items for undeclared variables are dropped, so large\n * values for variables outside the DTO are never accumulated.\n */\nexport class VariableCollector {\n  private readonly _queryNames: Set<string>;\n  private readonly _chosenValues = new Map<string, string>();\n  private readonly _scopesSeen = new Map<string, Set<string>>();\n\n  constructor(queryNames: Iterable<string>) {\n    this._queryNames = new Set(queryNames);\n  }\n\n  /** Fold one page of results into the retained per-name state. */\n  ingest(items: Iterable<TypedVariableItem>): void {\n    for (const item of items) {\n      if (!this._queryNames.has(item.name)) {\n        continue;\n      }\n      let scopes = this._scopesSeen.get(item.name);\n      if (!scopes) {\n        scopes = new Set();\n        this._scopesSeen.set(item.name, scopes);\n      }\n      scopes.add(item.scopeKey);\n      if (!this._chosenValues.has(item.name)) {\n        this._chosenValues.set(item.name, item.value);\n      }\n    }\n  }\n\n  /**\n   * Parse retained values, raising on scope collisions or malformed JSON.\n   * @throws {VariableScopeCollisionError} when a name was observed at more than one scope.\n   * @throws {VariableDeserializationError} when a retained value is not valid JSON.\n   */\n  build(): Record<string, unknown> {\n    const raw: Record<string, unknown> = {};\n    for (const [name, value] of this._chosenValues) {\n      const scopes = this._scopesSeen.get(name);\n      if (scopes && scopes.size > 1) {\n        throw new VariableScopeCollisionError(name, [...scopes].sort());\n      }\n      raw[name] = parseValue(name, value);\n    }\n    return raw;\n  }\n}\n\n/** Eventual-consistency tolerance for a DTO-driven variable search. */\nexport interface VariableConsistencyOptions {\n  /** How long to keep re-reading for the declared variables to become visible, in ms. `0` (the\n   * default) reads once and returns whatever is currently indexed. */\n  waitUpToMs: number;\n  /** How often to re-read while waiting, in ms. Defaults to 500ms (floored at 10ms). */\n  pollIntervalMs?: number;\n}\n\n/**\n * Injectable time source for {@link collectTypedVariables}'s consistency loop. Defaults to real\n * wall-clock time; tests supply a deterministic fake so polling behaviour is exercised without\n * real delays.\n */\nexport interface CollectClock {\n  now: () => number;\n  sleep: (ms: number) => Promise<void>;\n}\n\nconst realClock: CollectClock = {\n  now: () => liveClock.now(),\n  sleep: (ms) => liveClock.sleep(ms),\n};\n\n/**\n * Page through one full pass of the variable search, folding every page into `collector` and\n * returning the declared names still missing afterwards.\n *\n * Paging terminates when: the server reports no next cursor, a page comes back empty, or a cursor\n * repeats (a defensive guard against a server that never advances). The \"all declared names seen\"\n * early-stop is only applied when `singleScope` is true — i.e. the query is already scoped to a\n * single scope, where each name can appear at most once. When the query spans multiple scopes,\n * stopping early on \"all found\" could miss the same name reappearing at a second scope on a later\n * page, silently hiding a {@link VariableScopeCollisionError}; so paging continues to exhaustion.\n */\nasync function collectAllPages(params: {\n  names: readonly string[];\n  singleScope: boolean;\n  collector: VariableCollector;\n  fetchPage: (after: string | undefined) => Promise<TypedVariablePage>;\n}): Promise<Set<string>> {\n  const remaining = new Set(params.names);\n  const seenCursors = new Set<string>();\n  let after: string | undefined;\n\n  while (true) {\n    const page = await params.fetchPage(after);\n    params.collector.ingest(page.items);\n    for (const item of page.items) {\n      remaining.delete(item.name);\n    }\n\n    // Only safe to stop on \"all found\" when collisions are impossible (single scope). Otherwise\n    // a later page could reveal a second scope for an already-seen name — keep paging so build()\n    // can raise the collision rather than silently returning an ambiguous value.\n    if (params.singleScope && remaining.size === 0) {\n      break;\n    }\n    if (page.endCursor === null || page.items.length === 0) {\n      break;\n    }\n    if (seenCursors.has(page.endCursor)) {\n      break;\n    }\n    seenCursors.add(page.endCursor);\n    after = page.endCursor;\n  }\n\n  return remaining;\n}\n\n/**\n * Page through variable search results until every declared variable is found or the result set\n * is exhausted, then collapse them into a {@link VariableMap}.\n *\n * Eventual-consistency waiting (when `consistency.waitUpToMs > 0`) is applied here, at the\n * collection level — not on the underlying search calls. A freshly-written instance indexes its\n * declared variables independently, so an early read can return only a subset (e.g. `orderId`\n * before `amount`). Waiting on the first *search* alone is too weak: that search's success\n * condition is \"at least one matching variable\", so it settles on a partial result. Instead we\n * re-run the whole collection until every declared name is visible or the budget expires. On\n * expiry we return the best snapshot gathered so far rather than throwing: a genuinely-absent\n * variable is indistinguishable from a late one, and {@link VariableMap.validate} is the right\n * place to surface a missing required variable. This also keeps pagination correct — a paging\n * read that legitimately returns zero items never blocks, because the inner search never waits.\n *\n * The `fetchPage` callback isolates the HTTP call so the paging and collapse logic is\n * unit-testable in isolation; `clock` isolates time so the consistency loop is too.\n */\nexport async function collectTypedVariables<TSchema extends AnyVariableSchema>(params: {\n  schema: TSchema;\n  /** Whether the query is scoped to a single scope (collisions impossible, early-stop safe). */\n  singleScope: boolean;\n  fetchPage: (after: string | undefined) => Promise<TypedVariablePage>;\n  /** Eventual-consistency tolerance. Omitted or `waitUpToMs: 0` reads exactly once. */\n  consistency?: VariableConsistencyOptions;\n  /** Injectable clock for deterministic tests; defaults to real time. */\n  clock?: CollectClock;\n}): Promise<VariableMap<TSchema>> {\n  const names = variableNamesFromSchema(params.schema);\n  if (names.length === 0) {\n    return new VariableMap({}, params.schema);\n  }\n\n  const clock = params.clock ?? realClock;\n  const waitUpToMs = params.consistency?.waitUpToMs ?? 0;\n  const pollIntervalMs = Math.max(10, params.consistency?.pollIntervalMs ?? 500);\n  const deadline = clock.now() + waitUpToMs;\n\n  while (true) {\n    // A fresh collector each pass: re-reads must reflect the latest snapshot, not accumulate\n    // stale per-name state across attempts.\n    const collector = new VariableCollector(names);\n    const remaining = await collectAllPages({\n      names,\n      singleScope: params.singleScope,\n      collector,\n      fetchPage: params.fetchPage,\n    });\n\n    // All declared variables are visible, or we are out of budget: return the best snapshot.\n    if (remaining.size === 0 || waitUpToMs === 0 || clock.now() >= deadline) {\n      return new VariableMap(collector.build(), params.schema);\n    }\n\n    // Cap the wait so we never sleep past the deadline.\n    await clock.sleep(Math.min(pollIntervalMs, deadline - clock.now()));\n  }\n}\n\n/**\n * A cancelable in-flight request, mirroring the generated `CancelablePromise` (a `Promise` with an\n * extra `cancel()`). Kept structural here so the runtime core stays free of generated-type imports.\n */\nexport interface CancelableRequest<T> extends PromiseLike<T> {\n  cancel(): void;\n}\n\n/** The subset of the variable search response the page fetcher reads. */\nexport interface VariableSearchPageResponse {\n  items?: ReadonlyArray<{ name: string; value: string; scopeKey: unknown }> | null;\n  page?: { endCursor?: string | null } | null;\n}\n\n/** The request input the page fetcher builds for each page. */\nexport interface VariableSearchPageInput<TFilter> {\n  filter: TFilter;\n  page: { after?: string; limit: number };\n  truncateValues: boolean;\n}\n\n/**\n * Cross-runtime equivalent of `AbortSignal.prototype.throwIfAborted()`.\n *\n * `throwIfAborted` is a relatively recent addition and is not implemented in every browser the SDK\n * claims to support; calling it where absent throws a `TypeError` before any request is issued. We\n * feature-detect it and otherwise replicate its contract: throw the signal's `reason` when present,\n * or a synthesized `AbortError` when already aborted, so cancellation behaves consistently across\n * Node and browsers.\n */\nfunction throwIfAborted(signal: AbortSignal): void {\n  if (typeof signal.throwIfAborted === 'function') {\n    signal.throwIfAborted();\n    return;\n  }\n  if (signal.aborted) {\n    throw signal.reason ?? createAbortError();\n  }\n}\n\nfunction createAbortError(): Error {\n  if (typeof DOMException === 'function') {\n    return new DOMException('This operation was aborted', 'AbortError');\n  }\n  const error = new Error('This operation was aborted');\n  error.name = 'AbortError';\n  return error;\n}\n\n/**\n * Build the `fetchPage` callback for {@link collectTypedVariables} that drives the variable search\n * API. For each page it: aborts early if the outer signal is already aborted, issues the request\n * with the declared-name filter and `truncateValues: false` (full values are required to bind the\n * DTO), forwards outer cancellation to the in-flight request via its `cancel()`, and maps the raw\n * items into {@link TypedVariableItem}s.\n *\n * Transport is injected as `search`, so the input construction and cancellation propagation are\n * unit-testable without a live client.\n */\nexport function createVariableSearchFetchPage<TFilter>(params: {\n  filter: TFilter;\n  limit: number;\n  signal: AbortSignal;\n  search: (\n    input: VariableSearchPageInput<TFilter>\n  ) => CancelableRequest<VariableSearchPageResponse>;\n}): (after: string | undefined) => Promise<TypedVariablePage> {\n  const { filter, limit, signal, search } = params;\n  return async (after) => {\n    // Honour cancellation of the returned CancelablePromise between pages.\n    throwIfAborted(signal);\n    const input: VariableSearchPageInput<TFilter> = {\n      filter,\n      // Cursors are opaque; only an explicit `undefined` means \"no cursor\". An empty-string\n      // cursor is a valid value and must be forwarded as `page.after`.\n      page: after !== undefined ? { after, limit } : { limit },\n      truncateValues: false,\n    };\n    const pending = search(input);\n    // Propagate outer cancellation to the in-flight paging request so it aborts too.\n    const onAbort = () => pending.cancel();\n    signal.addEventListener('abort', onAbort, { once: true });\n    // Guard the race where the signal aborted between throwIfAborted() and addEventListener():\n    // the abort event already fired, so cancel the in-flight request explicitly.\n    if (signal.aborted) onAbort();\n    const result = await Promise.resolve(pending).finally(() =>\n      signal.removeEventListener('abort', onAbort)\n    );\n    const items = (result?.items ?? []).map((item) => ({\n      name: item.name,\n      value: item.value,\n      scopeKey: String(item.scopeKey),\n    }));\n    return { items, endCursor: result?.page?.endCursor ?? null };\n  };\n}\n","/*\n * Binds the generic pagination engine (`./pagination`) onto the generated\n * Camunda client so every `search*` operation gains a `.paginate(body, opts)`\n * method returning a lazy, cancelable async stream (issue #3).\n *\n * Design goals:\n *  - No enumeration of the 46 search ops. The runtime discovers them by the\n *    `search*` naming contract; the types discover them via a `search${string}`\n *    key filter and infer each op's body/item types from its own signature.\n *  - One well-known wiring point: `installSearchPagination(this)` is called once\n *    from the client constructor (in CamundaClient.template.ts).\n *  - The generated per-op methods are never edited.\n */\nimport type { ConsistencyOptions } from './eventual';\nimport {\n  type PaginateOptions,\n  type Paginator,\n  paginate,\n  type SearchBody,\n  type SearchResponse,\n} from './pagination';\n\n/** Options for `search*.paginate(...)`: page controls + per-call forwarding. */\nexport interface SearchPaginateOptions<TData> extends PaginateOptions {\n  /**\n   * Eventual-consistency controls forwarded to the underlying search call.\n   * Defaults to `{ waitUpToMs: 0 }` (ignore eventual consistency) when omitted.\n   *\n   * Only the **first** page honours this window: once paging is under way an\n   * empty page is a legitimate end-of-results, not a not-yet-consistent read,\n   * so subsequent (and exhaustion-probe) fetches always use `{ waitUpToMs: 0 }`.\n   * Waiting on those would make the terminal fetch of an exactly-full or empty\n   * result set block for the whole window and then throw.\n   */\n  consistency?: ConsistencyOptions<TData>;\n}\n\n/**\n * `search*` prototype members that match the `search[A-Z]` naming contract but\n * are hand-written helpers rather than generated search operations — they have\n * a different call shape and must never be wrapped with `.paginate`.\n */\nconst NON_PAGINATED_SEARCH_METHODS = new Set<string>(['searchVariablesAsDto']);\n\n/**\n * Combine the paginator's abort signal with any caller-supplied\n * `consistency.abortSignal` so that aborting the paginator also propagates into\n * the eventual-consistency layer. Returns `outer` unchanged when there is no\n * caller signal to preserve.\n */\nfunction mergeAbortSignals(outer: AbortSignal, inner?: AbortSignal): AbortSignal {\n  if (!inner) return outer;\n  const anyFn = (AbortSignal as { any?: (signals: AbortSignal[]) => AbortSignal }).any;\n  if (typeof anyFn === 'function') return anyFn([outer, inner]);\n  const ac = new AbortController();\n  if (outer.aborted || inner.aborted) {\n    ac.abort();\n    return ac.signal;\n  }\n  const onAbort = () => ac.abort();\n  outer.addEventListener('abort', onAbort, { once: true });\n  inner.addEventListener('abort', onAbort, { once: true });\n  return ac.signal;\n}\n\n/**\n * Attach a `.paginate` method to every `search*` operation on `client`.\n * Idempotent and enumeration-free: matches methods by the `search<Capital>`\n * naming contract on the prototype, excluding hand-written helpers whose call\n * shape is not `(body, consistency, options)`.\n */\nexport function installSearchPagination(client: object): void {\n  const seen = new Set<string>();\n  // Walk the prototype chain (stopping before Object.prototype) so a subclass\n  // of the generated client still gains `.paginate` on the generated `search*`\n  // methods it inherits — `Object.getPrototypeOf(client)` alone would only see\n  // the subclass's own prototype and skip every inherited search operation.\n  let proto = Object.getPrototypeOf(client) as Record<string, unknown> | null;\n  while (proto && proto !== Object.prototype) {\n    for (const name of Object.getOwnPropertyNames(proto)) {\n      if (seen.has(name)) continue;\n      if (!/^search[A-Z]/.test(name)) continue;\n      if (NON_PAGINATED_SEARCH_METHODS.has(name)) continue;\n      const method = proto[name];\n      if (typeof method !== 'function') continue;\n      seen.add(name);\n\n      const call = (method as (...a: unknown[]) => unknown).bind(client);\n\n      // Preserve the original callable (and its CancelablePromise return); add\n      // `.paginate` alongside it as a non-enumerable own property.\n      const wrapper = ((...args: unknown[]) => call(...args)) as ((\n        ...args: unknown[]\n      ) => unknown) & {\n        paginate?: (body: SearchBody, opts?: SearchPaginateOptions<unknown>) => Paginator<unknown>;\n      };\n\n      wrapper.paginate = (body: SearchBody, opts: SearchPaginateOptions<unknown> = {}) => {\n        const { consistency, ...pageOpts } = opts;\n        const fetchPage = (b: SearchBody, signal?: AbortSignal, isFirstPage = false) => {\n          // Eventual-consistency waiting only makes sense for the initial query:\n          // once we are paging forward an empty page means end-of-results, not an\n          // inconsistency, so waiting (and its terminal timeout error) must not\n          // apply to subsequent or exhaustion-probe fetches. `isFirstPage` is\n          // supplied per iterator run by the engine, so reusing the paginator\n          // does not leak the first-page window across iterators.\n          const baseConsistency = isFirstPage\n            ? (consistency ?? { waitUpToMs: 0 })\n            : { waitUpToMs: 0 };\n          // Thread the paginator's abort signal into the eventual-consistency\n          // options. Cancelling the returned promise (below) aborts the in-flight\n          // HTTP request, but when `waitUpToMs > 0` the search returns an\n          // `eventualPoll` wrapper whose own retry timer keeps issuing polls until\n          // its window elapses unless it sees an abort signal. Forwarding the\n          // signal here stops that poller too; any caller-supplied\n          // `consistency.abortSignal` is preserved.\n          const consistencyValue = signal\n            ? {\n                ...baseConsistency,\n                abortSignal: mergeAbortSignals(\n                  signal,\n                  (baseConsistency as { abortSignal?: AbortSignal }).abortSignal\n                ),\n              }\n            : baseConsistency;\n          const consistencyArg = { consistency: consistencyValue };\n          const p = call(b, consistencyArg) as Promise<SearchResponse<unknown>> & {\n            cancel?: () => void;\n          };\n          // Honour mid-flight cancellation: the underlying call is a\n          // CancelablePromise, so abort the in-flight page (not just between\n          // pages) and clean the listener up once the page settles. Register the\n          // listener *before* re-checking `signal.aborted` so an abort that fires\n          // between the check and the subscription is not missed.\n          if (signal) {\n            const onAbort = () => p.cancel?.();\n            signal.addEventListener('abort', onAbort, { once: true });\n            const cleanup = () => signal.removeEventListener('abort', onAbort);\n            p.then(cleanup, cleanup);\n            if (signal.aborted) p.cancel?.();\n          }\n          return p as Promise<SearchResponse<unknown>>;\n        };\n        return paginate(fetchPage, body, pageOpts);\n      };\n\n      Object.defineProperty(client, name, {\n        value: wrapper,\n        writable: true,\n        enumerable: false,\n        configurable: true,\n      });\n    }\n    proto = Object.getPrototypeOf(proto) as Record<string, unknown> | null;\n  }\n}\n\n// --- Type-level augmentation ------------------------------------------------\n// The client's generated search methods are overloaded (public typed signature\n// + `any` implementation signature). Conditional inference on an overloaded\n// function resolves to the *last* (impl) signature, which is untyped — so we\n// match a two-call-signature shape to bind the body/result of the *first*\n// (public) overload instead.\n\n/** Extract `{ body, result }` from a `search*` method's first (typed) overload. */\ntype SearchSignature<F> = F extends {\n  (body: infer B, consistency: infer _C, options?: infer _O): infer R;\n  (body: infer _B2, consistency: infer _C2, options?: infer _O2): infer _R2;\n}\n  ? { body: B; result: Awaited<R> }\n  : F extends (body: infer B, consistency: infer _C, options?: infer _O) => infer R\n    ? { body: B; result: Awaited<R> }\n    : never;\n\n/** The element type of a search response's `items` array. */\ntype ItemsOf<TData> = TData extends { items?: Array<infer I> } ? I : never;\n\n/**\n * For a client type `C`, the set of `.paginate` methods to intersect onto it.\n * Only `search*` keys whose response actually carries `items` are included.\n */\nexport type SearchPaginationApi<C> = {\n  [K in keyof C as K extends `search${string}`\n    ? SearchSignature<C[K]> extends { result: infer D }\n      ? [ItemsOf<D>] extends [never]\n        ? never\n        : K\n      : never\n    : never]: SearchSignature<C[K]> extends { body: infer B; result: infer D }\n    ? {\n        /**\n         * Stream this search across all pages as a lazy, cancelable async\n         * iterable. See `Paginator` for `.items()`, `.pages()`, `.toArray()`.\n         */\n        paginate(body: B, opts?: SearchPaginateOptions<D>): Paginator<ItemsOf<D>>;\n      }\n    : never;\n};\n\n/** A Camunda client augmented with `.paginate` on every search operation. */\nexport type WithSearchPagination<C> = C & SearchPaginationApi<C>;\n","import type { z } from 'zod';\nimport type { CamundaClient } from '../gen/CamundaClient';\nimport type { ActivateJobsResponses } from '../gen/types.gen';\nimport { isPresentWhenUnsupportedError } from './errors';\nimport type { EnrichedActivatedJob } from './jobActions';\nimport type { JobActionReceipt } from './jobWorker';\nimport {\n  DEFAULT_POLL_BACKOFF_MAX_MS,\n  DEFAULT_POLL_BACKOFF_MIN_MS,\n  nextActivationRetryDelayMs,\n} from './pollBackoff';\nimport type { ThreadPool } from './threadPool';\nimport { stopWorkerGracefully } from './workerGracefulStop';\nimport { WorkerStartGate } from './workerStartGate';\n\ntype ActivatedJobResult = ActivateJobsResponses[200]['jobs'][number];\n\n/**\n * The job object received by a threaded handler.\n * Same shape as EnrichedActivatedJob but without the logger (not available across threads).\n */\n/**\n * `clock` is omitted alongside `log` for the same reason: both are live in-process objects,\n * and a pinned clock cannot cross the worker-thread boundary. Threaded handlers use ambient\n * time — see camunda/orchestration-cluster-api-js#450.\n */\nexport type ThreadedJob = Omit<EnrichedActivatedJob, 'log' | 'clock'>;\n\n/**\n * Handler function signature for threaded job workers.\n *\n * Import this type in your handler module for full intellisense on `job` and `client`:\n *\n * ```ts\n * import type { ThreadedJobHandler } from '@camunda8/orchestration-cluster-api';\n *\n * const handler: ThreadedJobHandler = async (job, client) => {\n *   // full intellisense for job.variables, job.complete(), client.publishMessage(), etc.\n *   return job.complete({ result: 'done' });\n * };\n * export default handler;\n * ```\n */\nexport type ThreadedJobHandler = (\n  job: ThreadedJob,\n  client: CamundaClient\n) => Promise<JobActionReceipt> | JobActionReceipt;\n\n/**\n * Configuration for a threaded job worker.\n * Same as JobWorkerConfig but replaces `jobHandler` with `handlerModule`.\n */\nexport interface ThreadedJobWorkerConfig<\n  In extends z.ZodTypeAny = any,\n  Out extends z.ZodTypeAny = any,\n  Headers extends z.ZodTypeAny = any,\n> {\n  /** Absolute or relative path to a JS/TS module that exports a default handler function.\n   *  The function signature must be: `(job, client) => Promise<JobActionReceipt>` */\n  handlerModule: string;\n  /** Zod schema for variables in the activated job */\n  inputSchema?: In;\n  /** Zod schema for variables in the complete command */\n  outputSchema?: Out;\n  /** Zod schema for custom headers in the activated job */\n  customHeadersSchema?: Headers;\n  /** Backoff between polls - default 1ms */\n  pollIntervalMs?: number;\n  /**\n   * Floor (ms) of the exponential backoff applied between *failed* activation\n   * requests (connection refused, connect timeout, broker restart, LAN blip …).\n   * The first retry waits ≈ this/2–this ms; subsequent consecutive failures\n   * double the window up to {@link pollBackoffMaxMs}, with jitter, and reset to\n   * zero on the first successful poll. Default `1000`. Set to `0` to disable backoff (failed polls then fall back to {@link pollIntervalMs} rather than retrying immediately).\n   */\n  pollBackoffMinMs?: number;\n  /**\n   * Ceiling (ms) of the between-failed-poll exponential backoff. Default `30000`.\n   */\n  pollBackoffMaxMs?: number;\n  /** Immediately start polling for work - default `true` */\n  autoStart?: boolean;\n  /** Concurrency limit — default `10`. Overridden by CAMUNDA_WORKER_MAX_CONCURRENT_JOBS env var. */\n  maxParallelJobs?: number;\n  /**\n   * The request will be completed when at least one job is activated or after the requestTimeout.\n   * If the requestTimeout = 0, the request will be completed after a default configured timeout in the broker.\n   * To immediately complete the request when no job is activated set the requestTimeout to a negative value\n   */\n  pollTimeoutMs?: number;\n  /** Job activation timeout in ms — default `60000`. Overridden by CAMUNDA_WORKER_TIMEOUT env var. */\n  jobTimeoutMs?: number;\n  /** Zeebe job type */\n  jobType: string;\n  /** Optional list of variable names to fetch during activation */\n  fetchVariables?: In extends z.ZodTypeAny ? Array<Extract<keyof z.infer<In>, string>> : string[];\n  /**\n   * Activate jobs with a lease — default `false`.\n   *\n   * When `true`, each activated job is assigned a distinct, opaque lease token\n   * (`ActivatedJobResult.jobLeaseToken`) that is automatically threaded back into the\n   * fenced `complete` / `fail` / `error` commands. See {@link JobWorkerConfig.withLease}.\n   *\n   * Note: the threaded `jobHandler` intentionally keeps the base job shape\n   * (`jobLeaseToken` remains optional/nullable); the token is threaded back into\n   * fenced commands automatically, so handlers do not read it directly.\n   */\n  withLease?: boolean;\n  /** Optional explicit name */\n  workerName?: string;\n  /**\n   * Maximum random delay (in seconds) before the worker starts polling.\n   * When multiple application instances restart simultaneously, this spreads out\n   * initial activation requests to avoid saturating the server.\n   * `0` (the default) means no delay.\n   */\n  startupJitterMaxSeconds?: number;\n  /**\n   * Validate any provided input, output, customheader schema\n   * default: false\n   **/\n  validateSchemas?: boolean;\n  /**\n   * Number of threads in the shared pool (used only when the pool is first created;\n   * subsequent workers share the existing pool).\n   * Default: number of CPU cores available to the process.\n   */\n  threadPoolSize?: number;\n}\n\n/**\n * Internal shape after constructor defaults are applied: the defaulted fields\n * become required so the class body needs no non-null assertions on them. The\n * constructor's spread literal is checked against this type, so adding a new\n * defaulted field here without a matching default in the spread is a compile error.\n */\ntype ResolvedThreadedJobWorkerConfig = ThreadedJobWorkerConfig & {\n  pollIntervalMs: number;\n  pollBackoffMinMs: number;\n  pollBackoffMaxMs: number;\n  autoStart: boolean;\n  validateSchemas: boolean;\n  maxParallelJobs: number;\n  jobTimeoutMs: number;\n  withLease: boolean;\n};\n\nlet _workerCounter = 0;\n\nconst DEFAULT_LONGPOLL_TIMEOUT = 0;\n\n/**\n * A job worker that runs handler logic in a shared pool of worker_threads,\n * keeping the main Node.js event loop free for polling and I/O.\n *\n * The thread pool is owned by CamundaClient and shared across all threaded workers.\n * Each thread is generic — the handler module path is sent with each job,\n * and threads cache loaded handlers by module path.\n */\nexport class ThreadedJobWorker {\n  private _client: CamundaClient;\n  private _pool: ThreadPool;\n  private _cfg: ResolvedThreadedJobWorkerConfig;\n  private _maxParallelJobs: number;\n  private _jobTimeoutMs: number;\n  private _name: string;\n  private _activeJobs = 0;\n  private _stopped = false;\n  private _pollWait: AbortController | null = null;\n  private _inFlightActivation: any = null;\n  /** Consecutive failed activation requests; drives the retry backoff, reset on success. */\n  private _consecutiveActivationErrors = 0;\n  private _log: ReturnType<CamundaClient['logger']>;\n  private _jobQueue: Array<{ raw: ActivatedJobResult & Partial<EnrichedActivatedJob> }> = [];\n  private _startGate: WorkerStartGate;\n\n  constructor(client: CamundaClient, pool: ThreadPool, cfg: ThreadedJobWorkerConfig) {\n    this._client = client;\n    this._pool = pool;\n    // Nullish-coalesce each defaulted field so an explicitly-passed `undefined`\n    // cannot wipe out a required runtime default (a plain `{...defaults, ...cfg}`\n    // spread would let `maxParallelJobs: undefined` override the default).\n    this._cfg = {\n      ...cfg,\n      pollIntervalMs: cfg.pollIntervalMs ?? 1,\n      pollBackoffMinMs: cfg.pollBackoffMinMs ?? DEFAULT_POLL_BACKOFF_MIN_MS,\n      pollBackoffMaxMs: cfg.pollBackoffMaxMs ?? DEFAULT_POLL_BACKOFF_MAX_MS,\n      autoStart: cfg.autoStart ?? true,\n      validateSchemas: cfg.validateSchemas ?? false,\n      maxParallelJobs: cfg.maxParallelJobs ?? 10,\n      jobTimeoutMs: cfg.jobTimeoutMs ?? 60_000,\n      withLease: cfg.withLease ?? false,\n    };\n    this._maxParallelJobs = this._cfg.maxParallelJobs;\n    this._jobTimeoutMs = this._cfg.jobTimeoutMs;\n    this._name = cfg.workerName || `threaded-worker-${cfg.jobType}-${++_workerCounter}`;\n    this._log = this._client.logger().scope(`worker:${this._name}`);\n\n    // Drain queued jobs when a thread becomes ready or idle\n    this._pool.onThreadReady = () => this._drainQueue();\n\n    // The shared thread pool spawns its threads asynchronously, so the handle is\n    // returned before the transport can service a poll. Buffer start requests on\n    // the pool's readiness signal.\n    this._startGate = new WorkerStartGate(\n      () => this._pool.ready,\n      () => this._stopped\n    );\n    if (this._cfg.autoStart) this.start();\n  }\n\n  get name() {\n    return this._name;\n  }\n  get activeJobs() {\n    return this._activeJobs;\n  }\n  get stopped() {\n    return this._stopped;\n  }\n  /** Number of threads in the shared pool. */\n  get poolSize() {\n    return this._pool.size;\n  }\n  /** Number of threads currently processing a job (across all workers). */\n  get busyThreads() {\n    return this._pool.busyCount;\n  }\n  /** Resolves when the shared thread pool has finished initialising. */\n  get ready(): Promise<void> {\n    return this._pool.ready;\n  }\n\n  /**\n   * Begin polling for jobs. Safe to call at any point: the request is buffered\n   * until the shared thread pool is ready, and redundant calls (including an\n   * explicit call on an `autoStart` worker) are dropped rather than starting a\n   * second poll loop. Once the worker is stopped, `start()` is a no-op.\n   */\n  start() {\n    if (this._stopped) return;\n    let jitterMs = 0;\n    const accepted = this._startGate.request(\n      () => this._beginPolling(jitterMs),\n      (err) => this._log.error('worker.start.transportError', err)\n    );\n    if (!accepted) {\n      this._log.debug('worker.start.alreadyRequested');\n      return;\n    }\n    // Drawn at start(), not once the transport is ready, so workers started in sequence draw in order.\n    jitterMs = this._drawStartupJitterMs();\n    this._log.info('worker.start');\n  }\n\n  private _drawStartupJitterMs(): number {\n    const jitterMax = this._cfg.startupJitterMaxSeconds ?? 0;\n    return jitterMax > 0 ? Math.floor(this._client.random.next() * jitterMax * 1000) : 0;\n  }\n\n  private _beginPolling(jitterMs: number) {\n    if (jitterMs > 0) {\n      this._log.info(() => ['worker.start.jitter', { delayMs: jitterMs }]);\n      this._scheduleNext(jitterMs);\n    } else {\n      this._scheduleNext(0);\n    }\n  }\n\n  stop() {\n    this._stopped = true;\n    this._pollWait?.abort();\n    this._pollWait = null;\n    if (this._inFlightActivation?.cancel) {\n      try {\n        this._inFlightActivation.cancel();\n      } catch {\n        /* ignore */\n      }\n    }\n    this._log.info('worker.stop');\n  }\n\n  async stopGracefully(opts?: { waitUpToMs?: number; checkIntervalMs?: number }) {\n    return stopWorkerGracefully(\n      {\n        haltPolling: () => {\n          this._stopped = true;\n          this._pollWait?.abort();\n          this._pollWait = null;\n        },\n        activeJobs: () => this._activeJobs,\n        inFlightActivation: () => this._inFlightActivation,\n        log: this._log,\n      },\n      opts\n    );\n  }\n\n  // ─── Job dispatch ───\n\n  private _drainQueue() {\n    this._log.trace(() => [\n      'drain.start',\n      { queued: this._jobQueue.length, idle: this._pool.idleCount, active: this._activeJobs },\n    ]);\n    while (this._jobQueue.length > 0) {\n      const idle = this._pool.getIdleWorker();\n      if (!idle) {\n        this._log.trace(() => ['drain.noIdle', { queued: this._jobQueue.length }]);\n        break;\n      }\n      const item = this._jobQueue.shift()!;\n      this._log.trace(() => [\n        'drain.dispatch',\n        { jobKey: item.raw.jobKey, queued: this._jobQueue.length },\n      ]);\n      this._dispatchToThread(idle, item.raw);\n    }\n  }\n\n  private async _dispatchToThread(\n    pw: import('./threadPool').PoolWorker,\n    raw: ActivatedJobResult & Partial<EnrichedActivatedJob>\n  ) {\n    const jobData = this._serializeJob(raw);\n\n    this._log.trace(() => [\n      'dispatch.send',\n      { jobKey: raw.jobKey, handler: this._cfg.handlerModule },\n    ]);\n\n    this._pool.dispatch(pw, jobData, this._cfg.handlerModule, {\n      onComplete: (completionAction) => {\n        this._log.trace(() => [\n          'dispatch.onComplete',\n          {\n            jobKey: raw.jobKey,\n            hasAction: !!completionAction,\n            method: completionAction?.method,\n            active: this._activeJobs,\n          },\n        ]);\n        // Execute the completion API call on the main thread's event loop —\n        // this runs concurrently without blocking any worker thread.\n        if (completionAction) {\n          const { method, args } = completionAction;\n          const fn = (this._client as any)[method];\n          if (typeof fn === 'function') {\n            this._log.trace(() => ['dispatch.completion.fire', { jobKey: raw.jobKey, method }]);\n            fn.apply(this._client, args)\n              .then(() => {\n                this._log.trace(() => ['dispatch.completion.ok', { jobKey: raw.jobKey, method }]);\n              })\n              .catch((err: any) => {\n                this._log.error('job.completion.error', {\n                  jobKey: raw.jobKey,\n                  method,\n                  err: err?.message,\n                });\n              });\n          } else {\n            this._log.error('job.completion.noMethod', { jobKey: raw.jobKey, method });\n          }\n        } else {\n          this._log.trace(() => ['dispatch.onComplete.noAction', { jobKey: raw.jobKey }]);\n        }\n        this._decrementOnce();\n        this._drainQueue();\n      },\n      onError: (err) => {\n        this._log.error('job.thread.error', { jobKey: raw.jobKey, err });\n        this._client\n          .failJob({\n            jobKey: raw.jobKey!,\n            errorMessage: err?.message || 'Thread handler error',\n            retries: typeof raw.retries === 'number' ? Math.max(0, raw.retries - 1) : 0,\n            // Fence the failure against a superseded activation when leased.\n            ...(raw.jobLeaseToken != null ? { jobLeaseToken: raw.jobLeaseToken } : {}),\n          })\n          .catch((failErr: any) => {\n            this._log.error('job.fail.error', failErr);\n          })\n          .finally(() => {\n            this._decrementOnce();\n            this._drainQueue();\n          });\n      },\n    });\n  }\n\n  private _serializeJob(\n    raw: ActivatedJobResult & Partial<EnrichedActivatedJob>\n  ): Record<string, unknown> {\n    const data: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(raw)) {\n      if (typeof value === 'function') continue;\n      // Objects of functions survive the function check but JSON-collapse to `{}`, which\n      // would hand a threaded handler a clock whose methods are gone.\n      if (key === 'log' || key === 'clock') continue;\n      data[key] = value;\n    }\n    return JSON.parse(JSON.stringify(data));\n  }\n\n  // ─── Polling (same pattern as JobWorker) ───\n\n  private _scheduleNext(delayMs: number) {\n    if (this._stopped) return;\n    const wait = new AbortController();\n    this._pollWait = wait;\n    // Rejects when stop() aborts the wait; nothing to do in that case.\n    void this._client.clock.sleep(delayMs, wait.signal).then(\n      () => {\n        if (this._pollWait === wait) this._pollWait = null;\n        void this._poll();\n      },\n      () => {}\n    );\n  }\n\n  private async _poll() {\n    if (this._stopped) return;\n    // Belt and braces: the start gate already held the first poll until the pool\n    // was ready, so by here this resolves immediately.\n    await this._pool.ready;\n    if (this._activeJobs >= this._maxParallelJobs) {\n      this._scheduleNext(this._cfg.pollIntervalMs);\n      return;\n    }\n    // Activate up to the concurrency headroom. Jobs that arrive when all\n    // threads are busy are queued in _jobQueue and dispatched via _drainQueue\n    // as threads become idle, keeping the pipeline full.\n    const batchSize = this._maxParallelJobs - this._activeJobs;\n    if (batchSize <= 0) {\n      this._scheduleNext(this._cfg.pollIntervalMs);\n      return;\n    }\n    const body = {\n      type: this._cfg.jobType,\n      worker: this._name,\n      maxJobsToActivate: batchSize,\n      requestTimeout: this._cfg.pollTimeoutMs ?? DEFAULT_LONGPOLL_TIMEOUT,\n      timeout: this._jobTimeoutMs,\n      ...(this._cfg.fetchVariables && this._cfg.fetchVariables.length > 0\n        ? { fetchVariable: this._cfg.fetchVariables }\n        : {}),\n      ...(this._cfg.withLease ? { withLease: true } : {}),\n    };\n    this._log.debug(() => ['activation.request', { batchSize }]);\n    let result: ActivatedJobResult[] = [];\n    try {\n      this._inFlightActivation = this._client.activateJobs(body);\n      const activation = await this._inFlightActivation;\n      this._inFlightActivation = null;\n      // A successful poll (jobs or an empty long-poll) proves connectivity —\n      // clear the failure streak so the next error starts backoff from the floor.\n      this._consecutiveActivationErrors = 0;\n      result = activation?.jobs || [];\n      this._log.debug(() => ['activation.response', { jobs: result.length }]);\n    } catch (e) {\n      this._inFlightActivation = null;\n      if (this._stopped) return;\n      // Suppress logging + backoff for intentional cancellation (user-initiated stop).\n      if ((e as any)?.name === 'CancelSdkError') {\n        this._log.debug('activation.cancelled');\n        this._scheduleNext(this._cfg.pollIntervalMs);\n        return;\n      }\n      // Terminal, non-retryable fault: the server returned a response shape that\n      // cannot satisfy a requested dependent-presence contract (e.g. a lease was\n      // requested against a server that predates the feature). Backing off and\n      // retrying can never succeed — the same request yields the same unsupported\n      // shape forever — so stop the worker instead of looping. Mirrors JobWorker\n      // so the two implementations cannot drift.\n      if (isPresentWhenUnsupportedError(e)) {\n        this._log.error('activation.fatal', e);\n        this.stop();\n        return;\n      }\n      this._consecutiveActivationErrors += 1;\n      // nextActivationRetryDelayMs is the single source of truth shared with\n      // JobWorker so the two implementations cannot drift. When backoff is\n      // disabled (pollBackoffMinMs <= 0) it falls back to the normal poll interval\n      // rather than 0, which would spin an even tighter retry loop than the old\n      // behaviour — the opposite of what \"disable\" should mean.\n      const delayMs = nextActivationRetryDelayMs(this._consecutiveActivationErrors, this._cfg, () =>\n        this._client.random.next()\n      );\n      this._log.error('activation.error', e);\n      this._log.debug(() => [\n        'activation.retry',\n        { attempt: this._consecutiveActivationErrors, retryInMs: delayMs },\n      ]);\n      this._scheduleNext(delayMs);\n      return;\n    }\n    if (!result || result.length === 0) {\n      this._scheduleNext(this._cfg.pollIntervalMs);\n      return;\n    }\n    this._activeJobs += result.length;\n    this._scheduleNext(0);\n    for (const raw of result) {\n      this._handleJob(raw as ActivatedJobResult & Partial<EnrichedActivatedJob>);\n    }\n  }\n\n  private _handleJob(raw: ActivatedJobResult & Partial<EnrichedActivatedJob>) {\n    this._log.trace(() => [\n      'job.handle',\n      { jobKey: raw.jobKey, active: this._activeJobs, queued: this._jobQueue.length },\n    ]);\n    if (this._stopped) {\n      this._log.trace(() => ['job.handle.stopped', { jobKey: raw.jobKey }]);\n      this._decrementOnce();\n      return;\n    }\n    let variables: any = raw.variables;\n    let headers: any = raw.customHeaders;\n    if (this._cfg.validateSchemas) {\n      if (this._cfg.inputSchema) {\n        const parsed = this._cfg.inputSchema.safeParse(variables);\n        if (!parsed.success) {\n          this._log.warn('job.validation.variables.failed', parsed.error.flatten());\n          this._failValidation(raw as ActivatedJobResult, 'Invalid variables');\n          return;\n        }\n        variables = parsed.data;\n      }\n      if (this._cfg.customHeadersSchema) {\n        const parsed = this._cfg.customHeadersSchema.safeParse(headers);\n        if (!parsed.success) {\n          this._log.warn('job.validation.headers.failed', parsed.error.flatten());\n          this._failValidation(raw as ActivatedJobResult, 'Invalid custom headers');\n          return;\n        }\n        headers = parsed.data;\n      }\n    }\n    const enriched = Object.assign(raw, { variables, customHeaders: headers });\n    const idle = this._pool.getIdleWorker();\n    if (idle) {\n      this._log.trace(() => ['job.handle.dispatch', { jobKey: raw.jobKey }]);\n      this._dispatchToThread(idle, enriched);\n    } else {\n      this._log.trace(() => [\n        'job.handle.queued',\n        { jobKey: raw.jobKey, queueLen: this._jobQueue.length + 1 },\n      ]);\n      this._jobQueue.push({ raw: enriched });\n    }\n  }\n\n  private async _failValidation(raw: ActivatedJobResult, msg: string) {\n    try {\n      await this._client.failJob({\n        jobKey: raw.jobKey,\n        errorMessage: msg,\n        // Fence the failure against a superseded activation when leased.\n        ...(raw.jobLeaseToken != null ? { jobLeaseToken: raw.jobLeaseToken } : {}),\n      });\n    } catch (e) {\n      this._log.error('job.fail.validation.error', e);\n    } finally {\n      this._decrementOnce();\n    }\n  }\n\n  private _decrementOnce() {\n    const was = this._activeJobs;\n    this._activeJobs = Math.max(0, this._activeJobs - 1);\n    this._log.trace(() => ['job.active', { was, now: this._activeJobs }]);\n  }\n}\n","/**\n * Client proxy for worker_threads: allows threaded job handlers to call\n * CamundaClient methods transparently via MessagePort.\n *\n * Main thread side: installClientCallHandler(port, client)\n * Worker thread side: createClientProxy(port) → CamundaClient-shaped proxy\n */\n\nimport type { MessagePort } from 'node:worker_threads';\nimport type { CamundaClient } from '../gen/CamundaClient';\n\n// Wire protocol\nexport interface ClientCallMessage {\n  type: 'client-call';\n  callId: string;\n  method: string;\n  args: unknown[];\n}\n\nexport interface ClientCallResult {\n  type: 'client-call-result';\n  callId: string;\n  result?: unknown;\n  error?: string;\n}\n\n/** Fallback UUID generator for runtimes where globalThis.crypto.randomUUID is unavailable. */\nlet _counter = 0;\nfunction fallbackUUID(): string {\n  // biome-ignore lint/plugin: correlation-id entropy, not cadence\n  return `${Date.now().toString(36)}-${(++_counter).toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n}\n\n/**\n * Create a Proxy that looks like CamundaClient but forwards every method call\n * over a MessagePort to the main thread. Runs inside a worker thread.\n */\nexport function createClientProxy(port: MessagePort): CamundaClient {\n  return new Proxy({} as CamundaClient, {\n    get(_, method: string) {\n      // Ignore symbol properties and common non-method accesses\n      if (typeof method === 'symbol') return undefined;\n      if (method === 'then') return undefined; // Prevent Proxy from being treated as thenable\n      if (method === 'toJSON') return undefined;\n\n      return (...args: unknown[]) => {\n        const callId = globalThis.crypto?.randomUUID\n          ? globalThis.crypto.randomUUID()\n          : fallbackUUID();\n        const msg: ClientCallMessage = { type: 'client-call', callId, method, args };\n        port.postMessage(msg);\n        return new Promise<unknown>((resolve, reject) => {\n          const handler = (reply: ClientCallResult) => {\n            if (reply.type !== 'client-call-result' || reply.callId !== callId) return;\n            port.off('message', handler);\n            if (reply.error !== undefined) {\n              reject(new Error(reply.error));\n            } else {\n              resolve(reply.result);\n            }\n          };\n          port.on('message', handler);\n        });\n      };\n    },\n  });\n}\n\n/**\n * Install a message handler on a MessagePort (main thread side) that\n * receives client-call messages from a worker thread and executes them\n * on the real CamundaClient instance.\n */\nexport function installClientCallHandler(port: MessagePort, client: CamundaClient): void {\n  port.on('message', async (msg: ClientCallMessage) => {\n    if (msg.type !== 'client-call') return;\n    try {\n      const fn = (client as any)[msg.method];\n      if (typeof fn !== 'function') {\n        throw new Error(`CamundaClient has no method '${msg.method}'`);\n      }\n      const result = await fn.apply(client, msg.args);\n      const reply: ClientCallResult = { type: 'client-call-result', callId: msg.callId, result };\n      port.postMessage(reply);\n    } catch (err: any) {\n      const reply: ClientCallResult = {\n        type: 'client-call-result',\n        callId: msg.callId,\n        error: err?.message || String(err),\n      };\n      port.postMessage(reply);\n    }\n  });\n}\n","/**\n * Shared thread pool for ThreadedJobWorkers.\n *\n * Owned by CamundaClient and shared across all threaded workers in the process.\n * Each thread is generic — the handler module path is sent with each job message,\n * and threads cache loaded handlers by module path.\n *\n * Node built-ins come from the `#platform` seam, so browser bundles never see a\n * `node:` specifier (the browser build resolves `node` to `undefined`).\n */\n\nimport type { CamundaClient } from '../gen/CamundaClient';\nimport { installClientCallHandler } from './clientProxy';\nimport type { NodeBuiltins } from './platform/types';\nimport { node } from '#platform';\n\n/**\n * Minimal structural view of a `node:worker_threads` Worker — only the members the pool\n * actually uses. Typing the public `PoolWorker.worker` field structurally (rather than as\n * `import('node:worker_threads').Worker`) keeps `node:worker_threads` out of the published\n * `.d.ts`, so downstream consumers do not need `@types/node` to typecheck against this\n * package's types. A real Node `Worker` is structurally assignable to this. The runtime\n * implementation still constructs and uses the genuine Node Worker internally.\n */\nexport interface WorkerHandle {\n  postMessage(value: unknown, transferList?: readonly unknown[]): void;\n  terminate(): Promise<number>;\n  on(event: 'message', listener: (msg: any) => void): this;\n  on(event: 'error', listener: (err: Error) => void): this;\n  on(event: 'exit', listener: (code: number) => void): this;\n}\n\nexport interface PoolWorker {\n  worker: WorkerHandle;\n  busy: boolean;\n  ready: boolean;\n  /** The taskId currently being processed by this worker (if busy). */\n  currentTaskId?: string;\n}\n\nexport interface PendingJob {\n  resolve: (ok: boolean, completionAction?: { method: string; args: unknown[] }) => void;\n  reject: (err: Error) => void;\n}\n\n/** Lazily resolved Node.js modules (avoids top-level node: imports for browser bundlers). */\ninterface NodeModules {\n  MessageChannel: typeof import('node:worker_threads').MessageChannel;\n  randomUUID: typeof import('node:crypto').randomUUID;\n}\n\nexport class ThreadPool {\n  private _pool: PoolWorker[] = [];\n  private _pending: Map<string, PendingJob> = new Map();\n  private _node!: NodeModules;\n  private _log: ReturnType<CamundaClient['logger']>;\n  private _client: CamundaClient;\n  private _ready: Promise<void>;\n  private _terminated = false;\n  private _entryPath = '';\n  private _Worker!: typeof import('node:worker_threads').Worker;\n  private _onThreadReady?: () => void;\n\n  constructor(client: CamundaClient, size?: number) {\n    // Synchronous platform guard: threaded workers are Node-only. This must\n    // throw here — not only in the async `_init` — so `createThreadedJobWorker()`\n    // rejects the unsupported runtime immediately instead of returning an\n    // unusable handle whose auto-start path merely logs the async rejection.\n    if (!node) {\n      throw new Error('Threaded job workers are only available in Node.js environments');\n    }\n    this._client = client;\n    this._log = client.logger().scope('thread-pool');\n    this._ready = this._init(size);\n  }\n\n  /** Resolves when all threads have been spawned and signalled ready. */\n  get ready(): Promise<void> {\n    return this._ready;\n  }\n\n  /** Total number of threads in the pool. */\n  get size(): number {\n    return this._pool.length;\n  }\n\n  /** Number of threads currently processing a job. */\n  get busyCount(): number {\n    return this._pool.filter((pw) => pw.busy).length;\n  }\n\n  /** Number of threads that are ready and idle. */\n  get idleCount(): number {\n    return this._pool.filter((pw) => pw.ready && !pw.busy).length;\n  }\n\n  /** Register a callback invoked whenever a thread becomes ready or idle. */\n  set onThreadReady(cb: (() => void) | undefined) {\n    this._onThreadReady = cb;\n  }\n\n  /** Find the first ready & idle thread. */\n  getIdleWorker(): PoolWorker | undefined {\n    return this._pool.find((pw) => pw.ready && !pw.busy);\n  }\n\n  /**\n   * Dispatch a serialized job to a specific idle worker.\n   * The caller is responsible for checking idleness first.\n   */\n  async dispatch(\n    pw: PoolWorker,\n    jobData: Record<string, unknown>,\n    handlerModule: string,\n    callbacks: {\n      onComplete: (completionAction?: { method: string; args: unknown[] }) => void;\n      onError: (err: Error) => void;\n    }\n  ): Promise<void> {\n    const { randomUUID, MessageChannel } = this._node;\n    const taskId = randomUUID();\n    pw.busy = true;\n    pw.currentTaskId = taskId;\n\n    this._log.trace(() => ['pool.dispatch', { taskId, jobKey: jobData.jobKey, handlerModule }]);\n\n    const { port1: mainPort, port2: workerPort } = new MessageChannel();\n    installClientCallHandler(mainPort, this._client);\n\n    this._pending.set(taskId, {\n      resolve: (_ok: boolean, completionAction?: { method: string; args: unknown[] }) => {\n        this._log.trace(() => [\n          'pool.resolve',\n          { taskId, hasAction: !!completionAction, method: completionAction?.method },\n        ]);\n        this._pending.delete(taskId);\n        mainPort.close();\n        callbacks.onComplete(completionAction);\n      },\n      reject: (err: Error) => {\n        this._pending.delete(taskId);\n        mainPort.close();\n        callbacks.onError(err);\n      },\n    });\n\n    pw.worker.postMessage({ type: 'job', taskId, jobData, handlerModule, clientPort: workerPort }, [\n      workerPort,\n    ]);\n  }\n\n  /** Terminate all threads and reject any in-flight tasks. */\n  terminate(): void {\n    this._terminated = true;\n    for (const pw of this._pool) {\n      pw.worker.terminate().catch(() => {});\n    }\n    this._pool = [];\n    // Reject all pending tasks so callers don't hang.\n    for (const [, pending] of this._pending) {\n      pending.reject(new Error('Thread pool terminated'));\n    }\n    this._pending.clear();\n  }\n\n  /** Reject the pending task for a worker that errored/exited and reset its state. */\n  private _rejectWorkerTask(pw: PoolWorker, message: string): void {\n    pw.busy = false;\n    if (pw.currentTaskId) {\n      const pending = this._pending.get(pw.currentTaskId);\n      if (pending) {\n        this._pending.delete(pw.currentTaskId);\n        pending.reject(new Error(message));\n      }\n      pw.currentTaskId = undefined;\n    }\n  }\n\n  /** Replace a dead worker in the pool with a freshly spawned one. */\n  private _respawn(deadPw: PoolWorker): void {\n    const idx = this._pool.indexOf(deadPw);\n    if (idx === -1) return;\n    const newPw = this._spawnWorker();\n    this._pool[idx] = newPw;\n    this._log.info(() => ['thread.respawn', { index: idx }]);\n  }\n\n  /** Create a single worker thread and wire up its event handlers. */\n  private _spawnWorker(): PoolWorker {\n    const worker = new this._Worker(this._entryPath);\n    const pw: PoolWorker = { worker, busy: false, ready: false };\n\n    worker.on('message', (msg: any) => {\n      if (msg.type === 'ready') {\n        pw.ready = true;\n        this._log.debug(() => ['thread.ready']);\n        this._onThreadReady?.();\n        return;\n      }\n      if (msg.type === 'job-result') {\n        this._log.debug(() => [\n          'thread.job-result',\n          { taskId: msg.taskId, ok: msg.ok, error: msg.error },\n        ]);\n        this._log.trace(() => [\n          'thread.job-result.detail',\n          {\n            taskId: msg.taskId,\n            hasCompletionAction: !!msg.completionAction,\n            method: msg.completionAction?.method,\n            pending: this._pending.has(msg.taskId),\n          },\n        ]);\n        pw.busy = false;\n        pw.currentTaskId = undefined;\n        const pending = this._pending.get(msg.taskId);\n        if (pending) {\n          if (msg.ok) {\n            pending.resolve(true, msg.completionAction);\n          } else {\n            pending.reject(new Error(msg.error || 'Handler failed'));\n          }\n        } else {\n          this._log.warn('thread.job-result.noPending', { taskId: msg.taskId });\n        }\n        return;\n      }\n    });\n\n    worker.on('error', (err) => {\n      this._log.error('thread.error', err);\n      this._rejectWorkerTask(pw, `Worker thread error: ${err.message}`);\n      pw.ready = false;\n      // Note: 'exit' fires after 'error', so respawn is handled there.\n    });\n\n    worker.on('exit', (code) => {\n      if (!this._terminated) {\n        this._log.warn('thread.exit', { code });\n        this._rejectWorkerTask(pw, `Worker thread exited unexpectedly (code ${code})`);\n        this._respawn(pw);\n      }\n    });\n\n    return pw;\n  }\n\n  private async _init(requestedSize?: number): Promise<void> {\n    // The platform guard lives in the constructor (synchronous): when `node`\n    // is undefined the constructor threw before `_init` could run, so the\n    // definite presence of the Node built-ins is guaranteed here.\n    const n = node as NodeBuiltins;\n    const workerThreads = await n.loadWorkerThreads();\n    const { path: pathMod, crypto, fs, url } = n;\n    this._Worker = workerThreads.Worker;\n    const { join } = pathMod;\n\n    this._node = {\n      MessageChannel: workerThreads.MessageChannel,\n      randomUUID: crypto.randomUUID,\n    };\n\n    const cpus = await (async () => {\n      try {\n        const { os } = n;\n        return os.availableParallelism?.() || os.cpus().length;\n      } catch {\n        return 4;\n      }\n    })();\n    const size = requestedSize ?? cpus;\n\n    // __dirname works in CJS and vitest/tsx, but not in native ESM dist output.\n    // Derive directory from import.meta.url when available, falling back to __dirname.\n    const dir =\n      typeof __dirname !== 'undefined'\n        ? __dirname\n        : pathMod.dirname(url.fileURLToPath(import.meta.url));\n    const jsPath = join(dir, 'threadWorkerEntry.js');\n    if (fs.existsSync(jsPath)) {\n      // Production: compiled entry sits alongside this file in dist/\n      this._entryPath = jsPath;\n    } else {\n      // Dev/test: running from source (e.g. vitest), look for the compiled entry in dist/\n      const distPath = pathMod.resolve(dir, '..', '..', 'dist', 'threadWorkerEntry.js');\n      if (!fs.existsSync(distPath)) {\n        throw new Error(\n          `threadWorkerEntry.js not found at ${jsPath} or ${distPath}. Run \"npm run build\" first.`\n        );\n      }\n      this._entryPath = distPath;\n    }\n\n    for (let i = 0; i < size; i++) {\n      this._pool.push(this._spawnWorker());\n    }\n\n    this._log.info(() => ['thread-pool.init', { size, entryPath: this._entryPath }]);\n  }\n}\n","// @generated from CamundaClient.template.ts - DO NOT EDIT DIRECTLY\n\nimport type * as Sdk from '../gen/sdk.gen';\nimport type { ProcessInstanceKey, ScopeKey, TenantId, VariableFilter } from '../gen/types.gen';\nimport type { ActivatedJobResultWithJobLeaseToken, ActivatedJobResultWithoutJobLeaseToken } from '../gen/types.gen'; // present-when projection imports\nimport { CamundaCore, type CamundaOptions } from '../runtime/camundaCore';\nimport { type CancelablePromise, toCancelable } from '../runtime/cancelable';\nimport { JobWorker, type JobWorkerConfig } from '../runtime/jobWorker';\nimport { EnrichedActivatedJob, EnrichedActivatedJobOf } from '../runtime/jobActions';\nimport type { OperationOptions } from '../runtime/retry';\nimport { installSearchPagination, type WithSearchPagination } from '../runtime/searchPagination';\nimport { ThreadedJobWorker, type ThreadedJobWorkerConfig } from '../runtime/threadedJobWorker';\nimport { ThreadPool } from '../runtime/threadPool';\nimport {\n  type AnyVariableSchema,\n  collectTypedVariables,\n  createVariableSearchFetchPage,\n  type VariableMap,\n  variableNamesFromSchema,\n} from '../runtime/typedVariables';\nimport { node } from '#platform';\n\n// === AUTO-GENERATED CAMUNDA SUPPORT TYPES START ===\n// Generated\n// Operations: 244\ntype _RawReturn<F> = F extends (...a:any)=>Promise<infer R> ? R : never;\ntype _DataOf<F> = Exclude<_RawReturn<F> extends { data: infer D } ? D : _RawReturn<F>, undefined>;\nimport * as Ops from './operations.gen';\nimport type { activateAdHocSubProcessActivitiesInput, activateJobsInput, assignClientToGroupInput, assignClientToTenantInput, assignGroupToTenantInput, assignMappingRuleToGroupInput, assignMappingRuleToTenantInput, assignProcessInstanceBusinessIdInput, assignRoleToClientInput, assignRoleToGroupInput, assignRoleToMappingRuleInput, assignRoleToTenantInput, assignRoleToUserInput, assignUserTaskInput, assignUserToGroupInput, assignUserToTenantInput, broadcastSignalInput, cancelBatchOperationInput, cancelClusterRebalanceInput, cancelProcessInstanceInput, cancelProcessInstancesBatchOperationInput, changeClusterModeInput, changeClusterModeAsClusterAdminInput, completeJobInput, completeUserTaskInput, correlateMessageInput, createAdminUserInput, createAgentInstanceInput, createAuthorizationInput, createDeploymentInput, createDocumentInput, createDocumentLinkInput, createDocumentsInput, createElementInstanceVariablesInput, createGlobalClusterVariableInput, createGlobalTaskListenerInput, createGroupInput, createMappingRuleInput, createProcessInstanceInput, createRoleInput, createTenantInput, createTenantClusterVariableInput, createUserInput, deleteAuthorizationInput, deleteDecisionInstanceInput, deleteDecisionInstancesBatchOperationInput, deleteDocumentInput, deleteGlobalClusterVariableInput, deleteGlobalTaskListenerInput, deleteGroupInput, deleteHistoryBackupInput, deleteHistoryBackupAsClusterAdminInput, deleteMappingRuleInput, deleteProcessInstanceInput, deleteProcessInstancesBatchOperationInput, deleteResourceInput, deleteRoleInput, deleteRuntimeBackupInput, deleteRuntimeBackupAsClusterAdminInput, deleteRuntimeBackupStateInput, deleteRuntimeBackupStateAsClusterAdminInput, deleteTenantInput, deleteTenantClusterVariableInput, deleteUserInput, evaluateConditionalsInput, evaluateDecisionInput, evaluateExpressionInput, failJobInput, getAgentDefinitionInput, getAgentDefinitionConsistency, getAgentInstanceInput, getAgentInstanceConsistency, getAuditLogInput, getAuditLogConsistency, getAuthenticationInput, getAuthorizationInput, getAuthorizationConsistency, getBatchOperationInput, getBatchOperationConsistency, getClusterExportingStatusInput, getClusterRebalanceInput, getClusterStatusInput, getClusterTopologyInput, getClusterUpgradeStatusInput, getDecisionDefinitionInput, getDecisionDefinitionConsistency, getDecisionDefinitionXmlInput, getDecisionDefinitionXmlConsistency, getDecisionInstanceInput, getDecisionInstanceConsistency, getDecisionRequirementsInput, getDecisionRequirementsConsistency, getDecisionRequirementsXmlInput, getDecisionRequirementsXmlConsistency, getDocumentInput, getElementInstanceInput, getElementInstanceConsistency, getExportingStatusInput, getFormByKeyInput, getFormByKeyConsistency, getGlobalClusterVariableInput, getGlobalClusterVariableConsistency, getGlobalJobStatisticsInput, getGlobalJobStatisticsConsistency, getGlobalTaskListenerInput, getGlobalTaskListenerConsistency, getGroupInput, getGroupConsistency, getHistoryBackupInput, getHistoryBackupAsClusterAdminInput, getIncidentInput, getIncidentConsistency, getJobErrorStatisticsInput, getJobErrorStatisticsConsistency, getJobTimeSeriesStatisticsInput, getJobTimeSeriesStatisticsConsistency, getJobTypeStatisticsInput, getJobTypeStatisticsConsistency, getJobWorkerStatisticsInput, getJobWorkerStatisticsConsistency, getLicenseInput, getMappingRuleInput, getMappingRuleConsistency, getProcessDefinitionInput, getProcessDefinitionConsistency, getProcessDefinitionInstanceStatisticsInput, getProcessDefinitionInstanceStatisticsConsistency, getProcessDefinitionInstanceVersionStatisticsInput, getProcessDefinitionInstanceVersionStatisticsConsistency, getProcessDefinitionMessageSubscriptionStatisticsInput, getProcessDefinitionMessageSubscriptionStatisticsConsistency, getProcessDefinitionStatisticsInput, getProcessDefinitionStatisticsConsistency, getProcessDefinitionXmlInput, getProcessDefinitionXmlConsistency, getProcessInstanceInput, getProcessInstanceConsistency, getProcessInstanceCallHierarchyInput, getProcessInstanceCallHierarchyConsistency, getProcessInstanceSequenceFlowsInput, getProcessInstanceSequenceFlowsConsistency, getProcessInstanceStatisticsInput, getProcessInstanceStatisticsConsistency, getProcessInstanceStatisticsByDefinitionInput, getProcessInstanceStatisticsByDefinitionConsistency, getProcessInstanceStatisticsByErrorInput, getProcessInstanceStatisticsByErrorConsistency, getProcessInstanceWaitStateStatisticsInput, getProcessInstanceWaitStateStatisticsConsistency, getResourceInput, getResourceConsistency, getResourceContentInput, getResourceContentConsistency, getResourceContentBinaryInput, getResourceContentBinaryConsistency, getRestoreStatusInput, getRoleInput, getRoleConsistency, getRuntimeBackupInput, getRuntimeBackupAsClusterAdminInput, getRuntimeBackupStateInput, getRuntimeBackupStateAsClusterAdminInput, getStartProcessFormInput, getStartProcessFormConsistency, getStatusInput, getSystemConfigurationInput, getTenantInput, getTenantConsistency, getTenantClusterVariableInput, getTenantClusterVariableConsistency, getTopologyInput, getUsageMetricsInput, getUsageMetricsConsistency, getUserInput, getUserConsistency, getUserTaskInput, getUserTaskConsistency, getUserTaskFormInput, getUserTaskFormConsistency, getVariableInput, getVariableConsistency, listHistoryBackupsInput, listHistoryBackupsAsClusterAdminInput, listRuntimeBackupsInput, listRuntimeBackupsAsClusterAdminInput, listSecretsInput, migrateProcessInstanceInput, migrateProcessInstancesBatchOperationInput, modifyProcessInstanceInput, modifyProcessInstancesBatchOperationInput, pauseClusterExportingInput, pauseExportingInput, pinClockInput, publishMessageInput, resetClockInput, resolveIncidentInput, resolveIncidentsBatchOperationInput, resolveProcessInstanceIncidentsInput, resolveSecretsInput, restoreInput, restoreAsClusterAdminInput, resumeBatchOperationInput, resumeClusterExportingInput, resumeExportingInput, resumeProcessInstanceInput, resumeProcessInstancesBatchOperationInput, searchAgentDefinitionsInput, searchAgentDefinitionsConsistency, searchAgentInstanceHistoryInput, searchAgentInstanceHistoryConsistency, searchAgentInstancesInput, searchAgentInstancesConsistency, searchAuditLogsInput, searchAuditLogsConsistency, searchAuthorizationsInput, searchAuthorizationsConsistency, searchBatchOperationItemsInput, searchBatchOperationItemsConsistency, searchBatchOperationsInput, searchBatchOperationsConsistency, searchClientsForGroupInput, searchClientsForGroupConsistency, searchClientsForRoleInput, searchClientsForRoleConsistency, searchClientsForTenantInput, searchClientsForTenantConsistency, searchClusterVariablesInput, searchClusterVariablesConsistency, searchCorrelatedMessageSubscriptionsInput, searchCorrelatedMessageSubscriptionsConsistency, searchDecisionDefinitionsInput, searchDecisionDefinitionsConsistency, searchDecisionInstancesInput, searchDecisionInstancesConsistency, searchDecisionRequirementsInput, searchDecisionRequirementsConsistency, searchElementInstanceIncidentsInput, searchElementInstanceIncidentsConsistency, searchElementInstancesInput, searchElementInstancesConsistency, searchElementInstanceWaitStatesInput, searchElementInstanceWaitStatesConsistency, searchGlobalTaskListenersInput, searchGlobalTaskListenersConsistency, searchGroupIdsForTenantInput, searchGroupIdsForTenantConsistency, searchGroupsInput, searchGroupsConsistency, searchGroupsForRoleInput, searchGroupsForRoleConsistency, searchIncidentsInput, searchIncidentsConsistency, searchJobsInput, searchJobsConsistency, searchMappingRuleInput, searchMappingRuleConsistency, searchMappingRulesForGroupInput, searchMappingRulesForGroupConsistency, searchMappingRulesForRoleInput, searchMappingRulesForRoleConsistency, searchMappingRulesForTenantInput, searchMappingRulesForTenantConsistency, searchMessageSubscriptionsInput, searchMessageSubscriptionsConsistency, searchOwnAuthorizationsInput, searchOwnAuthorizationsConsistency, searchProcessDefinitionsInput, searchProcessDefinitionsConsistency, searchProcessDefinitionVariableNamesInput, searchProcessDefinitionVariableNamesConsistency, searchProcessInstanceIncidentsInput, searchProcessInstanceIncidentsConsistency, searchProcessInstancesInput, searchProcessInstancesConsistency, searchResourcesInput, searchResourcesConsistency, searchRolesInput, searchRolesConsistency, searchRolesForGroupInput, searchRolesForGroupConsistency, searchRolesForTenantInput, searchRolesForTenantConsistency, searchTenantsInput, searchTenantsConsistency, searchUsersInput, searchUsersConsistency, searchUsersForGroupInput, searchUsersForGroupConsistency, searchUsersForRoleInput, searchUsersForRoleConsistency, searchUsersForTenantInput, searchUsersForTenantConsistency, searchUserTaskAuditLogsInput, searchUserTaskAuditLogsConsistency, searchUserTaskEffectiveVariablesInput, searchUserTaskEffectiveVariablesConsistency, searchUserTasksInput, searchUserTasksConsistency, searchUserTaskVariablesInput, searchUserTaskVariablesConsistency, searchVariablesInput, searchVariablesConsistency, suspendBatchOperationInput, suspendProcessInstanceInput, suspendProcessInstancesBatchOperationInput, syncRuntimeBackupStateInput, syncRuntimeBackupStateAsClusterAdminInput, takeHistoryBackupInput, takeHistoryBackupAsClusterAdminInput, takeRuntimeBackupInput, takeRuntimeBackupAsClusterAdminInput, throwJobErrorInput, triggerClusterRebalanceInput, unassignClientFromGroupInput, unassignClientFromTenantInput, unassignGroupFromTenantInput, unassignMappingRuleFromGroupInput, unassignMappingRuleFromTenantInput, unassignRoleFromClientInput, unassignRoleFromGroupInput, unassignRoleFromMappingRuleInput, unassignRoleFromTenantInput, unassignRoleFromUserInput, unassignUserFromGroupInput, unassignUserFromTenantInput, unassignUserTaskInput, updateAgentInstanceInput, updateAuthorizationInput, updateGlobalClusterVariableInput, updateGlobalTaskListenerInput, updateGroupInput, updateJobInput, updateJobsBatchOperationInput, updateMappingRuleInput, updateRoleInput, updateTenantInput, updateTenantClusterVariableInput, updateUserInput, updateUserTaskInput, ExtendedDeploymentResult } from './operations.gen';\nexport type { activateAdHocSubProcessActivitiesInput, activateJobsInput, assignClientToGroupInput, assignClientToTenantInput, assignGroupToTenantInput, assignMappingRuleToGroupInput, assignMappingRuleToTenantInput, assignProcessInstanceBusinessIdInput, assignRoleToClientInput, assignRoleToGroupInput, assignRoleToMappingRuleInput, assignRoleToTenantInput, assignRoleToUserInput, assignUserTaskInput, assignUserToGroupInput, assignUserToTenantInput, broadcastSignalInput, cancelBatchOperationInput, cancelClusterRebalanceInput, cancelProcessInstanceInput, cancelProcessInstancesBatchOperationInput, changeClusterModeInput, changeClusterModeAsClusterAdminInput, completeJobInput, completeUserTaskInput, correlateMessageInput, createAdminUserInput, createAgentInstanceInput, createAuthorizationInput, createDeploymentInput, createDocumentInput, createDocumentLinkInput, createDocumentsInput, createElementInstanceVariablesInput, createGlobalClusterVariableInput, createGlobalTaskListenerInput, createGroupInput, createMappingRuleInput, createProcessInstanceInput, createRoleInput, createTenantInput, createTenantClusterVariableInput, createUserInput, deleteAuthorizationInput, deleteDecisionInstanceInput, deleteDecisionInstancesBatchOperationInput, deleteDocumentInput, deleteGlobalClusterVariableInput, deleteGlobalTaskListenerInput, deleteGroupInput, deleteHistoryBackupInput, deleteHistoryBackupAsClusterAdminInput, deleteMappingRuleInput, deleteProcessInstanceInput, deleteProcessInstancesBatchOperationInput, deleteResourceInput, deleteRoleInput, deleteRuntimeBackupInput, deleteRuntimeBackupAsClusterAdminInput, deleteRuntimeBackupStateInput, deleteRuntimeBackupStateAsClusterAdminInput, deleteTenantInput, deleteTenantClusterVariableInput, deleteUserInput, evaluateConditionalsInput, evaluateDecisionInput, evaluateExpressionInput, failJobInput, getAgentDefinitionInput, getAgentDefinitionConsistency, getAgentInstanceInput, getAgentInstanceConsistency, getAuditLogInput, getAuditLogConsistency, getAuthenticationInput, getAuthorizationInput, getAuthorizationConsistency, getBatchOperationInput, getBatchOperationConsistency, getClusterExportingStatusInput, getClusterRebalanceInput, getClusterStatusInput, getClusterTopologyInput, getClusterUpgradeStatusInput, getDecisionDefinitionInput, getDecisionDefinitionConsistency, getDecisionDefinitionXmlInput, getDecisionDefinitionXmlConsistency, getDecisionInstanceInput, getDecisionInstanceConsistency, getDecisionRequirementsInput, getDecisionRequirementsConsistency, getDecisionRequirementsXmlInput, getDecisionRequirementsXmlConsistency, getDocumentInput, getElementInstanceInput, getElementInstanceConsistency, getExportingStatusInput, getFormByKeyInput, getFormByKeyConsistency, getGlobalClusterVariableInput, getGlobalClusterVariableConsistency, getGlobalJobStatisticsInput, getGlobalJobStatisticsConsistency, getGlobalTaskListenerInput, getGlobalTaskListenerConsistency, getGroupInput, getGroupConsistency, getHistoryBackupInput, getHistoryBackupAsClusterAdminInput, getIncidentInput, getIncidentConsistency, getJobErrorStatisticsInput, getJobErrorStatisticsConsistency, getJobTimeSeriesStatisticsInput, getJobTimeSeriesStatisticsConsistency, getJobTypeStatisticsInput, getJobTypeStatisticsConsistency, getJobWorkerStatisticsInput, getJobWorkerStatisticsConsistency, getLicenseInput, getMappingRuleInput, getMappingRuleConsistency, getProcessDefinitionInput, getProcessDefinitionConsistency, getProcessDefinitionInstanceStatisticsInput, getProcessDefinitionInstanceStatisticsConsistency, getProcessDefinitionInstanceVersionStatisticsInput, getProcessDefinitionInstanceVersionStatisticsConsistency, getProcessDefinitionMessageSubscriptionStatisticsInput, getProcessDefinitionMessageSubscriptionStatisticsConsistency, getProcessDefinitionStatisticsInput, getProcessDefinitionStatisticsConsistency, getProcessDefinitionXmlInput, getProcessDefinitionXmlConsistency, getProcessInstanceInput, getProcessInstanceConsistency, getProcessInstanceCallHierarchyInput, getProcessInstanceCallHierarchyConsistency, getProcessInstanceSequenceFlowsInput, getProcessInstanceSequenceFlowsConsistency, getProcessInstanceStatisticsInput, getProcessInstanceStatisticsConsistency, getProcessInstanceStatisticsByDefinitionInput, getProcessInstanceStatisticsByDefinitionConsistency, getProcessInstanceStatisticsByErrorInput, getProcessInstanceStatisticsByErrorConsistency, getProcessInstanceWaitStateStatisticsInput, getProcessInstanceWaitStateStatisticsConsistency, getResourceInput, getResourceConsistency, getResourceContentInput, getResourceContentConsistency, getResourceContentBinaryInput, getResourceContentBinaryConsistency, getRestoreStatusInput, getRoleInput, getRoleConsistency, getRuntimeBackupInput, getRuntimeBackupAsClusterAdminInput, getRuntimeBackupStateInput, getRuntimeBackupStateAsClusterAdminInput, getStartProcessFormInput, getStartProcessFormConsistency, getStatusInput, getSystemConfigurationInput, getTenantInput, getTenantConsistency, getTenantClusterVariableInput, getTenantClusterVariableConsistency, getTopologyInput, getUsageMetricsInput, getUsageMetricsConsistency, getUserInput, getUserConsistency, getUserTaskInput, getUserTaskConsistency, getUserTaskFormInput, getUserTaskFormConsistency, getVariableInput, getVariableConsistency, listHistoryBackupsInput, listHistoryBackupsAsClusterAdminInput, listRuntimeBackupsInput, listRuntimeBackupsAsClusterAdminInput, listSecretsInput, migrateProcessInstanceInput, migrateProcessInstancesBatchOperationInput, modifyProcessInstanceInput, modifyProcessInstancesBatchOperationInput, pauseClusterExportingInput, pauseExportingInput, pinClockInput, publishMessageInput, resetClockInput, resolveIncidentInput, resolveIncidentsBatchOperationInput, resolveProcessInstanceIncidentsInput, resolveSecretsInput, restoreInput, restoreAsClusterAdminInput, resumeBatchOperationInput, resumeClusterExportingInput, resumeExportingInput, resumeProcessInstanceInput, resumeProcessInstancesBatchOperationInput, searchAgentDefinitionsInput, searchAgentDefinitionsConsistency, searchAgentInstanceHistoryInput, searchAgentInstanceHistoryConsistency, searchAgentInstancesInput, searchAgentInstancesConsistency, searchAuditLogsInput, searchAuditLogsConsistency, searchAuthorizationsInput, searchAuthorizationsConsistency, searchBatchOperationItemsInput, searchBatchOperationItemsConsistency, searchBatchOperationsInput, searchBatchOperationsConsistency, searchClientsForGroupInput, searchClientsForGroupConsistency, searchClientsForRoleInput, searchClientsForRoleConsistency, searchClientsForTenantInput, searchClientsForTenantConsistency, searchClusterVariablesInput, searchClusterVariablesConsistency, searchCorrelatedMessageSubscriptionsInput, searchCorrelatedMessageSubscriptionsConsistency, searchDecisionDefinitionsInput, searchDecisionDefinitionsConsistency, searchDecisionInstancesInput, searchDecisionInstancesConsistency, searchDecisionRequirementsInput, searchDecisionRequirementsConsistency, searchElementInstanceIncidentsInput, searchElementInstanceIncidentsConsistency, searchElementInstancesInput, searchElementInstancesConsistency, searchElementInstanceWaitStatesInput, searchElementInstanceWaitStatesConsistency, searchGlobalTaskListenersInput, searchGlobalTaskListenersConsistency, searchGroupIdsForTenantInput, searchGroupIdsForTenantConsistency, searchGroupsInput, searchGroupsConsistency, searchGroupsForRoleInput, searchGroupsForRoleConsistency, searchIncidentsInput, searchIncidentsConsistency, searchJobsInput, searchJobsConsistency, searchMappingRuleInput, searchMappingRuleConsistency, searchMappingRulesForGroupInput, searchMappingRulesForGroupConsistency, searchMappingRulesForRoleInput, searchMappingRulesForRoleConsistency, searchMappingRulesForTenantInput, searchMappingRulesForTenantConsistency, searchMessageSubscriptionsInput, searchMessageSubscriptionsConsistency, searchOwnAuthorizationsInput, searchOwnAuthorizationsConsistency, searchProcessDefinitionsInput, searchProcessDefinitionsConsistency, searchProcessDefinitionVariableNamesInput, searchProcessDefinitionVariableNamesConsistency, searchProcessInstanceIncidentsInput, searchProcessInstanceIncidentsConsistency, searchProcessInstancesInput, searchProcessInstancesConsistency, searchResourcesInput, searchResourcesConsistency, searchRolesInput, searchRolesConsistency, searchRolesForGroupInput, searchRolesForGroupConsistency, searchRolesForTenantInput, searchRolesForTenantConsistency, searchTenantsInput, searchTenantsConsistency, searchUsersInput, searchUsersConsistency, searchUsersForGroupInput, searchUsersForGroupConsistency, searchUsersForRoleInput, searchUsersForRoleConsistency, searchUsersForTenantInput, searchUsersForTenantConsistency, searchUserTaskAuditLogsInput, searchUserTaskAuditLogsConsistency, searchUserTaskEffectiveVariablesInput, searchUserTaskEffectiveVariablesConsistency, searchUserTasksInput, searchUserTasksConsistency, searchUserTaskVariablesInput, searchUserTaskVariablesConsistency, searchVariablesInput, searchVariablesConsistency, suspendBatchOperationInput, suspendProcessInstanceInput, suspendProcessInstancesBatchOperationInput, syncRuntimeBackupStateInput, syncRuntimeBackupStateAsClusterAdminInput, takeHistoryBackupInput, takeHistoryBackupAsClusterAdminInput, takeRuntimeBackupInput, takeRuntimeBackupAsClusterAdminInput, throwJobErrorInput, triggerClusterRebalanceInput, unassignClientFromGroupInput, unassignClientFromTenantInput, unassignGroupFromTenantInput, unassignMappingRuleFromGroupInput, unassignMappingRuleFromTenantInput, unassignRoleFromClientInput, unassignRoleFromGroupInput, unassignRoleFromMappingRuleInput, unassignRoleFromTenantInput, unassignRoleFromUserInput, unassignUserFromGroupInput, unassignUserFromTenantInput, unassignUserTaskInput, updateAgentInstanceInput, updateAuthorizationInput, updateGlobalClusterVariableInput, updateGlobalTaskListenerInput, updateGroupInput, updateJobInput, updateJobsBatchOperationInput, updateMappingRuleInput, updateRoleInput, updateTenantInput, updateTenantClusterVariableInput, updateUserInput, updateUserTaskInput, ExtendedDeploymentResult } from './operations.gen';\nconst VOID_RESPONSES = 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']);\n// === AUTO-GENERATED CAMUNDA SUPPORT TYPES END ===\n\n// Cancelable primitive (kept lightweight & local)\nexport class CancelError extends Error {\n  constructor() {\n    super('Cancelled');\n    this.name = 'CancelError';\n  }\n}\nexport type { CamundaOptions, CancelablePromise };\n\nexport function createCamundaClient(options?: CamundaOptions): CamundaClient {\n  return new CamundaClient(options);\n}\n\n/**\n * The Camunda client's operation methods. Create clients with {@link createCamundaClient}\n * or {@link CamundaClient}, which add `.paginate(...)` to every search operation.\n */\nexport class CamundaClientBase extends CamundaCore {\n  /** Registered job workers created via createJobWorker (lifecycle managed by user). */\n  private _workers: any[] = [];\n  /** Shared thread pool for all threaded job workers (lazy-initialised on first use). */\n  private _threadPool: ThreadPool | null = null;\n\n  constructor(opts: CamundaOptions = {}) {\n    // Discriminate the full client from bare `CamundaCore` (and consumer subclasses of\n    // it) for support diagnostics — see `CamundaOptions.__camundaComponent`.\n    super({ ...opts, __camundaComponent: 'CamundaClient' });\n    // Attach `.paginate` to every search* operation (issue #3). One well-known\n    // wiring point; discovers search methods generically (no per-op list).\n    installSearchPagination(this);\n  }\n\n  // Helper for detecting documented void responses (stable public contract).\n  // The generated per-operation functions carry their own copy of the set.\n  // Uses build-time generated VOID_RESPONSES set (no runtime zod dependency needed)\n  private _isVoidResponse(name: string): boolean {\n    return VOID_RESPONSES.has(name);\n  }\n\n  // Lazy-load the full zod schema module. Returns cached module. Operations load\n  // their own per-operation schema module instead (see operations.gen.ts); this\n  // stays on the class (not the core) so the per-operation entry point does not\n  // reference the whole schema module.\n  private _schemasPromise: Promise<typeof import('../gen/zod.gen')> | null = null;\n  private _loadSchemas(): Promise<typeof import('../gen/zod.gen')> {\n    if (!this._schemasPromise) {\n      this._schemasPromise = import('../gen/zod.gen');\n    }\n    return this._schemasPromise;\n  }\n\n  /** Return a read-only snapshot of currently registered job workers. */\n  getWorkers() {\n    return [...this._workers];\n  }\n  /** Stop all registered job workers (best-effort) and terminate the shared thread pool. */\n  stopAllWorkers() {\n    for (const w of this._workers) {\n      try {\n        if (typeof w.stop === 'function') w.stop();\n      } catch (e) {\n        this._log.warn('worker.stop.error', e);\n      }\n    }\n    if (this._threadPool) {\n      this._threadPool.terminate();\n      this._threadPool = null;\n    }\n  }\n\n  /** Get or lazily create the shared thread pool for threaded job workers. */\n  private _getOrCreateThreadPool(threadPoolSize?: number): ThreadPool {\n    if (!this._threadPool) {\n      this._threadPool = new ThreadPool(this as any, threadPoolSize);\n    }\n    return this._threadPool;\n  }\n  // === AUTO-GENERATED CAMUNDA METHODS START ===\n  // Generated methods: each delegates to its standalone function in operations.gen.ts\n  /**\n   * Activate activities within an ad-hoc sub-process\n   *\n   * Activates selected activities within an ad-hoc sub-process identified by element ID.\n   * The provided element IDs must exist within the ad-hoc sub-process instance identified by the\n   * provided adHocSubProcessInstanceKey.\n   *\n    *\n   * @example Activate ad-hoc sub-process activities\n   * ```ts\n   * async function activateAdHocSubProcessActivitiesExample(\n   *   adHocSubProcessInstanceKey: ElementInstanceKey,\n   *   elementId: ElementId\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.activateAdHocSubProcessActivities({\n   *     adHocSubProcessInstanceKey,\n   *     elements: [{ elementId }],\n   *   });\n   * }\n   * ```\n   * @operationId activateAdHocSubProcessActivities\n   * @tags Ad-hoc sub-process\n   */\n  activateAdHocSubProcessActivities(input: activateAdHocSubProcessActivitiesInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.activateAdHocSubProcessActivities>>;\n  activateAdHocSubProcessActivities(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.activateAdHocSubProcessActivities(this, arg, options);\n  }\n\n  /**\n   * Activate jobs\n   *\n   * Iterate through all known partitions and activate jobs up to the requested maximum.\n   *\n    *\n   * @example Activate and process jobs\n   * ```ts\n   * async function activateJobsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.activateJobs({\n   *     type: 'payment-processing',\n   *     timeout: 30000,\n   *     maxJobsToActivate: 5,\n   *   });\n   * \n   *   for (const job of result.jobs) {\n   *     console.log(`Job ${job.jobKey}: ${job.type}`);\n   * \n   *     // Each enriched job has helper methods\n   *     await job.complete({ paymentId: 'PAY-123' });\n   *   }\n   * }\n   * ```\n   * @operationId activateJobs\n   * @tags Job\n   */\n  activateJobs(input: activateJobsInput & { withLease: true }, options?: OperationOptions): CancelablePromise<{ jobs: EnrichedActivatedJobOf<ActivatedJobResultWithJobLeaseToken>[] }>;\n  activateJobs(input: activateJobsInput & { withLease?: false | null | undefined }, options?: OperationOptions): CancelablePromise<{ jobs: EnrichedActivatedJobOf<ActivatedJobResultWithoutJobLeaseToken>[] }>;\n  activateJobs(input: activateJobsInput, options?: OperationOptions): CancelablePromise<{ jobs: EnrichedActivatedJob[] }>;\n  activateJobs(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.activateJobs(this, arg, options);\n  }\n\n  /**\n   * Assign a client to a group\n   *\n   * Assigns a client to a group, making it a member of the group.\n   * Members of the group inherit the group authorizations, roles, and tenant assignments.\n   *\n    *\n   * @example Assign a client to a group\n   * ```ts\n   * async function assignClientToGroupExample(groupId: GroupId, clientId: ClientId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignClientToGroup({\n   *     groupId,\n   *     clientId,\n   *   });\n   * }\n   * ```\n   * @operationId assignClientToGroup\n   * @tags Group\n   */\n  assignClientToGroup(input: assignClientToGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignClientToGroup>>;\n  assignClientToGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignClientToGroup(this, arg, options);\n  }\n\n  /**\n   * Assign a client to a tenant\n   *\n   * Assign the client to the specified tenant.\n   * The client can then access tenant data and perform authorized actions.\n   *\n    *\n   * @example Assign a client to a tenant\n   * ```ts\n   * async function assignClientToTenantExample(tenantId: TenantId, clientId: ClientId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignClientToTenant({\n   *     tenantId,\n   *     clientId,\n   *   });\n   * }\n   * ```\n   * @operationId assignClientToTenant\n   * @tags Tenant\n   */\n  assignClientToTenant(input: assignClientToTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignClientToTenant>>;\n  assignClientToTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignClientToTenant(this, arg, options);\n  }\n\n  /**\n   * Assign a group to a tenant\n   *\n   * Assigns a group to a specified tenant.\n   * Group members (users, clients) can then access tenant data and perform authorized actions.\n   *\n    *\n   * @example Assign a group to a tenant\n   * ```ts\n   * async function assignGroupToTenantExample(tenantId: TenantId, groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignGroupToTenant({\n   *     tenantId,\n   *     groupId,\n   *   });\n   * }\n   * ```\n   * @operationId assignGroupToTenant\n   * @tags Tenant\n   */\n  assignGroupToTenant(input: assignGroupToTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignGroupToTenant>>;\n  assignGroupToTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignGroupToTenant(this, arg, options);\n  }\n\n  /**\n   * Assign a mapping rule to a group\n   *\n   * Assigns a mapping rule to a group.\n    *\n   * @example Assign a mapping rule to a group\n   * ```ts\n   * async function assignMappingRuleToGroupExample(groupId: GroupId, mappingRuleId: MappingRuleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignMappingRuleToGroup({\n   *     groupId,\n   *     mappingRuleId,\n   *   });\n   * }\n   * ```\n   * @operationId assignMappingRuleToGroup\n   * @tags Group\n   */\n  assignMappingRuleToGroup(input: assignMappingRuleToGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignMappingRuleToGroup>>;\n  assignMappingRuleToGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignMappingRuleToGroup(this, arg, options);\n  }\n\n  /**\n   * Assign a mapping rule to a tenant\n   *\n   * Assign a single mapping rule to a specified tenant.\n    *\n   * @example Assign a mapping rule to a tenant\n   * ```ts\n   * async function assignMappingRuleToTenantExample(tenantId: TenantId, mappingRuleId: MappingRuleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignMappingRuleToTenant({\n   *     tenantId,\n   *     mappingRuleId,\n   *   });\n   * }\n   * ```\n   * @operationId assignMappingRuleToTenant\n   * @tags Tenant\n   */\n  assignMappingRuleToTenant(input: assignMappingRuleToTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignMappingRuleToTenant>>;\n  assignMappingRuleToTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignMappingRuleToTenant(this, arg, options);\n  }\n\n  /**\n   * Assign business id to process instance\n   *\n   * Assigns a business id to an already-running process instance that currently has none.\n   *\n   * The assignment is single and irreversible: only artifacts created after the assignment\n   * (for example future jobs, user tasks, decision instances, and message subscriptions) carry\n   * the business id, while existing artifacts are not retroactively enriched. Re-sending the\n   * same business id succeeds as a no-op. This endpoint is only useful while business id\n   * uniqueness enforcement is disabled; when it is enabled, the request is rejected with a 409\n   * response.\n   *\n    *\n   * @example Assign a business ID to a process instance\n   * ```ts\n   * async function assignProcessInstanceBusinessIdExample(\n   *   processInstanceKey: ProcessInstanceKey,\n   *   businessId: BusinessId\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignProcessInstanceBusinessId({\n   *     processInstanceKey,\n   *     businessId,\n   *   });\n   * }\n   * ```\n   * @operationId assignProcessInstanceBusinessId\n   * @tags Process instance\n   */\n  assignProcessInstanceBusinessId(input: assignProcessInstanceBusinessIdInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignProcessInstanceBusinessId>>;\n  assignProcessInstanceBusinessId(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignProcessInstanceBusinessId(this, arg, options);\n  }\n\n  /**\n   * Assign a role to a client\n   *\n   * Assigns the specified role to the client. The client will inherit the authorizations associated with this role.\n    *\n   * @example Assign a role to a client\n   * ```ts\n   * async function assignRoleToClientExample(roleId: RoleId, clientId: ClientId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignRoleToClient({\n   *     roleId,\n   *     clientId,\n   *   });\n   * }\n   * ```\n   * @operationId assignRoleToClient\n   * @tags Role\n   */\n  assignRoleToClient(input: assignRoleToClientInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignRoleToClient>>;\n  assignRoleToClient(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignRoleToClient(this, arg, options);\n  }\n\n  /**\n   * Assign a role to a group\n   *\n   * Assigns the specified role to the group. Every member of the group (user or client) will inherit the authorizations associated with this role.\n    *\n   * @example Assign a role to a group\n   * ```ts\n   * async function assignRoleToGroupExample(roleId: RoleId, groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignRoleToGroup({\n   *     roleId,\n   *     groupId,\n   *   });\n   * }\n   * ```\n   * @operationId assignRoleToGroup\n   * @tags Role\n   */\n  assignRoleToGroup(input: assignRoleToGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignRoleToGroup>>;\n  assignRoleToGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignRoleToGroup(this, arg, options);\n  }\n\n  /**\n   * Assign a role to a mapping rule\n   *\n   * Assigns a role to a mapping rule.\n    *\n   * @example Assign a role to a mapping rule\n   * ```ts\n   * async function assignRoleToMappingRuleExample(roleId: RoleId, mappingRuleId: MappingRuleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignRoleToMappingRule({\n   *     roleId,\n   *     mappingRuleId,\n   *   });\n   * }\n   * ```\n   * @operationId assignRoleToMappingRule\n   * @tags Role\n   */\n  assignRoleToMappingRule(input: assignRoleToMappingRuleInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignRoleToMappingRule>>;\n  assignRoleToMappingRule(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignRoleToMappingRule(this, arg, options);\n  }\n\n  /**\n   * Assign a role to a tenant\n   *\n   * Assigns a role to a specified tenant.\n   * Users, Clients or Groups, that have the role assigned, will get access to the tenant's data and can perform actions according to their authorizations.\n   *\n    *\n   * @example Assign a role to a tenant\n   * ```ts\n   * async function assignRoleToTenantExample(tenantId: TenantId, roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignRoleToTenant({\n   *     tenantId,\n   *     roleId,\n   *   });\n   * }\n   * ```\n   * @operationId assignRoleToTenant\n   * @tags Tenant\n   */\n  assignRoleToTenant(input: assignRoleToTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignRoleToTenant>>;\n  assignRoleToTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignRoleToTenant(this, arg, options);\n  }\n\n  /**\n   * Assign a role to a user\n   *\n   * Assigns the specified role to the user. The user will inherit the authorizations associated with this role.\n    *\n   * @example Assign a role to a user\n   * ```ts\n   * async function assignRoleToUserExample(roleId: RoleId, username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignRoleToUser({\n   *     roleId,\n   *     username,\n   *   });\n   * }\n   * ```\n   * @operationId assignRoleToUser\n   * @tags Role\n   */\n  assignRoleToUser(input: assignRoleToUserInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignRoleToUser>>;\n  assignRoleToUser(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignRoleToUser(this, arg, options);\n  }\n\n  /**\n   * Assign user task\n   *\n   * Assigns a user task with the given key to the given assignee. Assignment waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.\n   *\n    *\n   * @example Assign a user task\n   * ```ts\n   * async function assignUserTaskExample(userTaskKey: UserTaskKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignUserTask({\n   *     userTaskKey,\n   *     assignee: 'alice',\n   *     allowOverride: true,\n   *   });\n   * }\n   * ```\n   * @operationId assignUserTask\n   * @tags User task\n   */\n  assignUserTask(input: assignUserTaskInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignUserTask>>;\n  assignUserTask(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignUserTask(this, arg, options);\n  }\n\n  /**\n   * Assign a user to a group\n   *\n   * Assigns a user to a group, making the user a member of the group.\n   * Group members inherit the group authorizations, roles, and tenant assignments.\n   *\n    *\n   * @example Assign a user to a group\n   * ```ts\n   * async function assignUserToGroupExample(groupId: GroupId, username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignUserToGroup({\n   *     groupId,\n   *     username,\n   *   });\n   * }\n   * ```\n   * @operationId assignUserToGroup\n   * @tags Group\n   */\n  assignUserToGroup(input: assignUserToGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignUserToGroup>>;\n  assignUserToGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignUserToGroup(this, arg, options);\n  }\n\n  /**\n   * Assign a user to a tenant\n   *\n   * Assign a single user to a specified tenant. The user can then access tenant data and perform authorized actions.\n    *\n   * @example Assign a user to a tenant\n   * ```ts\n   * async function assignUserToTenantExample(tenantId: TenantId, username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.assignUserToTenant({\n   *     tenantId,\n   *     username,\n   *   });\n   * }\n   * ```\n   * @operationId assignUserToTenant\n   * @tags Tenant\n   */\n  assignUserToTenant(input: assignUserToTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.assignUserToTenant>>;\n  assignUserToTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.assignUserToTenant(this, arg, options);\n  }\n\n  /**\n   * Broadcast signal\n   *\n   * Broadcasts a signal.\n    *\n   * @example Broadcast a signal\n   * ```ts\n   * async function broadcastSignalExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.broadcastSignal({\n   *     signalName: 'system-shutdown',\n   *     variables: {\n   *       reason: 'Scheduled maintenance',\n   *     },\n   *   });\n   * \n   *   console.log(`Signal broadcast key: ${result.signalKey}`);\n   * }\n   * ```\n   * @operationId broadcastSignal\n   * @tags Signal\n   */\n  broadcastSignal(input: broadcastSignalInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.broadcastSignal>>;\n  broadcastSignal(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.broadcastSignal(this, arg, options);\n  }\n\n  /**\n   * Cancel Batch operation\n   *\n   * Cancels a running batch operation.\n   * This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Cancel a batch operation\n   * ```ts\n   * async function cancelBatchOperationExample(batchOperationKey: BatchOperationKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.cancelBatchOperation({ batchOperationKey });\n   * }\n   * ```\n   * @operationId cancelBatchOperation\n   * @tags Batch operation\n   */\n  cancelBatchOperation(input: cancelBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.cancelBatchOperation>>;\n  cancelBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.cancelBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Stop the running rebalance\n   *\n   * Asks the running rebalance to stop once the transfer in flight has finished. Partitions already transferred keep their new leaders, and those the rebalance had not yet reached keep their current ones.\n   *\n   * Cancellation requests are idempotent and always accepted. The `wasRunning` response field can be used to distinguish a cancellation that found a running rebalance from one that did not.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here.\n    *\n   * @example Cancel the running cluster rebalance\n   * ```ts\n   * async function cancelClusterRebalanceExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.cancelClusterRebalance();\n   * \n   *   console.log(`Cancel requested; was a rebalance running? ${result.wasRunning}`);\n   * }\n   * ```\n   * @operationId cancelClusterRebalance\n   * @tags Cluster\n   */\n  cancelClusterRebalance(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.cancelClusterRebalance>>;\n  cancelClusterRebalance(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.cancelClusterRebalance(this, options);\n  }\n\n  /**\n   * Cancel process instance\n   *\n   * Cancels a running process instance. As a cancellation includes more than just the removal of the process instance resource, the cancellation resource must be posted. Cancellation can wait on listener-related processing; when that processing does not complete in time, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.\n   *\n    *\n   * @example Cancel a process instance\n   * ```ts\n   * async function cancelProcessInstanceExample(processDefinitionId: ProcessDefinitionId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Create a process instance and get its key from the response\n   *   const created = await camunda.createProcessInstance({\n   *     processDefinitionId,\n   *   });\n   * \n   *   // Cancel the process instance using the key from the creation response\n   *   await camunda.cancelProcessInstance({\n   *     processInstanceKey: created.processInstanceKey,\n   *   });\n   * }\n   * ```\n   * @operationId cancelProcessInstance\n   * @tags Process instance\n   */\n  cancelProcessInstance(input: cancelProcessInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.cancelProcessInstance>>;\n  cancelProcessInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.cancelProcessInstance(this, arg, options);\n  }\n\n  /**\n   * Cancel process instances (batch)\n   *\n   * Cancels multiple active or suspended process instances.\n   * Only ACTIVE and SUSPENDED root instances can be cancelled. A state filter narrows the batch\n   * to the given states. Requesting any state other than ACTIVE or SUSPENDED through the `$eq` or\n   * `$in` operators is rejected. Other state operators (`$neq`, `$exists`, `$like`) are applied as\n   * given, and the batch remains limited to ACTIVE and SUSPENDED instances. Without a state filter,\n   * both ACTIVE and SUSPENDED instances are selected. Any given filter for parentProcessInstanceKey\n   * is ignored and overridden during this batch operation.\n   * This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Cancel process instances in batch\n   * ```ts\n   * async function cancelProcessInstancesBatchOperationExample(\n   *   processDefinitionKey: ProcessDefinitionKey\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.cancelProcessInstancesBatchOperation({\n   *     filter: {\n   *       processDefinitionKey,\n   *     },\n   *   });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId cancelProcessInstancesBatchOperation\n   * @tags Process instance\n   */\n  cancelProcessInstancesBatchOperation(input: cancelProcessInstancesBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.cancelProcessInstancesBatchOperation>>;\n  cancelProcessInstancesBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.cancelProcessInstancesBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Change cluster mode\n   *\n   * Transitions the cluster between processing and recovery mode. This is a non-blocking operation: the request is acknowledged once the change has been accepted, before the transition itself has completed. Entering recovery mode deactivates all partitions so that only a restricted set of read-only operations remains available; exiting recovery mode returns the cluster to normal processing. Returns the planned cluster change so its progress can be monitored via the topology.\n    *\n   * @example Change cluster mode\n   * ```ts\n   * async function changeClusterModeExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Transition the cluster into recovery mode. Pass `dryRun: true` to validate\n   *   // the request and inspect the resulting plan without applying it. Omit it (or\n   *   // set it to false) to actually trigger the transition.\n   *   const change = await camunda.changeClusterMode({\n   *     mode: 'RECOVERING',\n   *     dryRun: true,\n   *   });\n   * \n   *   // Operations are grouped by physical tenant; a null tenant means the operation\n   *   // is not scoped to one, such as a broker lifecycle operation.\n   *   console.log(`Cluster change ${change.changeId}:`);\n   *   for (const group of change.plannedChanges) {\n   *     console.log(`  ${group.physicalTenantId ?? 'cluster-wide'}:`);\n   *     for (const op of group.operations) {\n   *       console.log(`    ${op.operation}${op.mode ? ` -> ${op.mode}` : ''}`);\n   *     }\n   *   }\n   * }\n   * ```\n   * @operationId changeClusterMode\n   * @tags Recovery\n   */\n  changeClusterMode(input: changeClusterModeInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.changeClusterMode>>;\n  changeClusterMode(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.changeClusterMode(this, arg, options);\n  }\n\n  /**\n   * Change the cluster mode of one or every physical tenant\n   *\n   * Transitions physical tenants between processing and recovery mode.\n   *\n   * If the `physicalTenantId` parameter is not provided, all available physical tenants are transitioned individually.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here.\n    *\n   * @example Change cluster mode as cluster admin\n   * ```ts\n   * async function changeClusterModeAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // The cluster-admin variant can target a single physical tenant. Omit\n   *   // `physicalTenantId` to apply the change to every physical tenant.\n   *   const change = await camunda.changeClusterModeAsClusterAdmin({\n   *     mode: 'RECOVERING',\n   *     physicalTenantId: 'default',\n   *     dryRun: true,\n   *   });\n   * \n   *   console.log(`Cluster change ${change.changeId}:`);\n   *   for (const group of change.plannedChanges) {\n   *     console.log(`  ${group.physicalTenantId ?? 'cluster-wide'}:`);\n   *     for (const op of group.operations) {\n   *       console.log(`    ${op.operation}${op.mode ? ` -> ${op.mode}` : ''}`);\n   *     }\n   *   }\n   * }\n   * ```\n   * @operationId changeClusterModeAsClusterAdmin\n   * @tags Recovery\n   */\n  changeClusterModeAsClusterAdmin(input: changeClusterModeAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.changeClusterModeAsClusterAdmin>>;\n  changeClusterModeAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.changeClusterModeAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Complete job\n   *\n   * Complete a job with the given payload, which allows completing the associated service task.\n   *\n    *\n   * @example Complete a job\n   * ```ts\n   * async function completeJobExample(jobKey: JobKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.completeJob({\n   *     jobKey,\n   *     variables: {\n   *       paymentId: 'PAY-123',\n   *       status: 'completed',\n   *     },\n   *   });\n   * }\n   * ```\n   * @operationId completeJob\n   * @tags Job\n   */\n  completeJob(input: completeJobInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.completeJob>>;\n  completeJob(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.completeJob(this, arg, options);\n  }\n\n  /**\n   * Complete user task\n   *\n   * Completes a user task with the given key. Completion waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.\n   *\n    *\n   * @example Complete a user task\n   * ```ts\n   * async function completeUserTaskExample(userTaskKey: UserTaskKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.completeUserTask({\n   *     userTaskKey,\n   *     variables: {\n   *       approved: true,\n   *       comment: 'Looks good',\n   *     },\n   *   });\n   * }\n   * ```\n   * @operationId completeUserTask\n   * @tags User task\n   */\n  completeUserTask(input: completeUserTaskInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.completeUserTask>>;\n  completeUserTask(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.completeUserTask(this, arg, options);\n  }\n\n  /**\n   * Correlate message\n   *\n   * Publishes a message and correlates it to a subscription.\n   * If correlation is successful it will return the first process instance key the message correlated with.\n   * The message is not buffered.\n   * Use the publish message endpoint to send messages that can be buffered.\n   *\n    *\n   * @example Correlate a message\n   * ```ts\n   * async function correlateMessageExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.correlateMessage({\n   *     name: 'order-payment-received',\n   *     correlationKey: 'ORD-12345',\n   *     variables: {\n   *       paymentId: 'PAY-123',\n   *       amount: 99.95,\n   *     },\n   *   });\n   * \n   *   console.log(`Message correlated to: ${result.processInstanceKey}`);\n   * }\n   * ```\n   * @operationId correlateMessage\n   * @tags Message\n   */\n  correlateMessage(input: correlateMessageInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.correlateMessage>>;\n  correlateMessage(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.correlateMessage(this, arg, options);\n  }\n\n  /**\n   * Create admin user\n   *\n   * Creates a new user and assigns the admin role to it. This endpoint is only usable when users are managed in the Orchestration Cluster and while no user is assigned to the admin role.\n    *\n   * @example Create an admin user\n   * ```ts\n   * async function createAdminUserExample(username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createAdminUser({\n   *     username,\n   *     name: 'Admin User',\n   *     email: 'admin@example.com',\n   *     password: 'admin-password-123',\n   *   });\n   * \n   *   console.log(`Created admin user: ${result.username}`);\n   * }\n   * ```\n   * @operationId createAdminUser\n   * @tags Setup\n   */\n  createAdminUser(input: createAdminUserInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createAdminUser>>;\n  createAdminUser(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createAdminUser(this, arg, options);\n  }\n\n  /**\n   * Create agent instance\n   *\n   * Creates a new agent instance. The returned key identifies the instance and must\n   * be used in subsequent update and query calls.\n   *\n    *\n   * @example Create an agent instance\n   * ```ts\n   * async function createAgentInstanceExample(\n   *   elementInstanceKey: ElementInstanceKey,\n   *   jobKey: JobKey,\n   *   jobLeaseToken: JobLeaseToken\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   // The batch must open with a CONFIGURATION item; it establishes the model,\n   *   // provider and system prompt for the instance.\n   *   const result = await camunda.createAgentInstance({\n   *     elementInstanceKey,\n   *     jobKey,\n   *     jobLeaseToken,\n   *     history: [\n   *       {\n   *         historyItemId: HistoryItemId.assumeExists('configuration-1'),\n   *         loopIteration: 1,\n   *         role: 'CONFIGURATION',\n   *         content: [],\n   *         producedAt: new Date().toISOString(),\n   *         model: 'gpt-4o',\n   *         provider: 'openai',\n   *         systemPrompt: [{ contentType: 'TEXT', text: 'You are a helpful assistant.' }],\n   *       },\n   *     ],\n   *   });\n   * \n   *   console.log(`Created agent instance: ${result.agentInstanceKey}`);\n   * }\n   * ```\n   * @operationId createAgentInstance\n   * @tags Agent instance\n   */\n  createAgentInstance(input: createAgentInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createAgentInstance>>;\n  createAgentInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createAgentInstance(this, arg, options);\n  }\n\n  /**\n   * Create authorization\n   *\n   * Create the authorization.\n    *\n   * @example Create an authorization\n   * ```ts\n   * async function createAuthorizationExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createAuthorization({\n   *     ownerId: 'user-123',\n   *     ownerType: 'USER',\n   *     resourceId: 'order-process',\n   *     resourceType: 'PROCESS_DEFINITION',\n   *     permissionTypes: ['CREATE_PROCESS_INSTANCE', 'READ_PROCESS_INSTANCE'],\n   *   });\n   * \n   *   console.log(`Authorization key: ${result.authorizationKey}`);\n   * }\n   * ```\n   * @operationId createAuthorization\n   * @tags Authorization\n   */\n  createAuthorization(input: createAuthorizationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createAuthorization>>;\n  createAuthorization(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createAuthorization(this, arg, options);\n  }\n\n  /**\n   * Deploy resources\n   *\n   * Deploys one or more resources, including BPMN processes, DMN decision models, forms, RPA resources, and generic files.\n   * A deployment can contain any file type. Files that are not interpreted as BPMN, DMN, form, or RPA resources are stored as deployable generic resources in the engine.\n   * This is an atomic call, i.e. either all resources are deployed or none of them are.\n   *\n    *\n   * @example Deploy resources from files\n   * ```ts\n   * async function deployResourcesFromFilesExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Node.js only: deploy directly from file paths\n   *   const result = await camunda.deployResourcesFromFiles(['./process.bpmn', './decision.dmn']);\n   * \n   *   console.log(`Deployment key: ${result.deploymentKey}`);\n   * }\n   * ```\n   * @operationId createDeployment\n   * @tags Resource\n   * @returns Enriched deployment result with typed arrays (processes, decisions, decisionRequirements, forms, resources).\n   */\n  createDeployment(input: createDeploymentInput, options?: OperationOptions): CancelablePromise<ExtendedDeploymentResult>;\n  createDeployment(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createDeployment(this, arg, options);\n  }\n\n  /**\n   * Upload document\n   *\n   * Upload a document to the Camunda 8 cluster.\n   *\n   * Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)\n   *\n    *\n   * @example Upload a document\n   * ```ts\n   * async function createDocumentExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const file = new Blob(['Hello, world!'], { type: 'text/plain' });\n   * \n   *   const result = await camunda.createDocument({\n   *     file,\n   *     metadata: { fileName: 'hello.txt' },\n   *   });\n   * \n   *   console.log(`Document ID: ${result.documentId}`);\n   * }\n   * ```\n   * @operationId createDocument\n   * @tags Document\n   */\n  createDocument(input: createDocumentInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createDocument>>;\n  createDocument(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createDocument(this, arg, options);\n  }\n\n  /**\n   * Create document link\n   *\n   * Create a link to a document in the Camunda 8 cluster.\n   *\n   * Note that this is currently supported for document stores of type: AWS, Azure, GCP\n   *\n    *\n   * @example Create a document link\n   * ```ts\n   * async function createDocumentLinkExample(documentId: DocumentId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const link = await camunda.createDocumentLink({\n   *     documentId,\n   *     timeToLive: 3600000,\n   *   });\n   * \n   *   console.log(`Document link: ${link.url}`);\n   * }\n   * ```\n   * @operationId createDocumentLink\n   * @tags Document\n   */\n  createDocumentLink(input: createDocumentLinkInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createDocumentLink>>;\n  createDocumentLink(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createDocumentLink(this, arg, options);\n  }\n\n  /**\n   * Upload multiple documents\n   *\n   * Upload multiple documents to the Camunda 8 cluster.\n   *\n   * The caller must provide a file name for each document, which will be used in case of a multi-status response\n   * to identify which documents failed to upload. The file name can be provided in the `Content-Disposition` header\n   * of the file part or in the `fileName` field of the metadata. You can add a parallel array of metadata objects. These\n   * are matched with the files based on index, and must have the same length as the files array.\n   * To pass homogenous metadata for all files, spread the metadata over the metadata array.\n   * A filename value provided explicitly via the metadata array in the request overrides the `Content-Disposition` header\n   * of the file part.\n   *\n   * In case of a multi-status response, the response body will contain a list of `DocumentBatchProblemDetail` objects,\n   * each of which contains the file name of the document that failed to upload and the reason for the failure.\n   * The client can choose to retry the whole batch or individual documents based on the response.\n   *\n   * Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)\n   *\n    *\n   * @example Upload multiple documents\n   * ```ts\n   * async function createDocumentsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const file1 = new Blob(['File one'], { type: 'text/plain' });\n   *   const file2 = new Blob(['File two'], { type: 'text/plain' });\n   * \n   *   const result = await camunda.createDocuments({\n   *     files: [file1, file2],\n   *     metadataList: [{ fileName: 'one.txt' }, { fileName: 'two.txt' }],\n   *   });\n   * \n   *   for (const doc of result.createdDocuments ?? []) {\n   *     console.log(`Created: ${doc.documentId}`);\n   *   }\n   * }\n   * ```\n   * @operationId createDocuments\n   * @tags Document\n   */\n  createDocuments(input: createDocumentsInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createDocuments>>;\n  createDocuments(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createDocuments(this, arg, options);\n  }\n\n  /**\n   * Update element instance variables\n   *\n   * Updates all the variables of a particular scope (for example, process instance, element instance) with the given variable data.\n   * Specify the element instance in the `elementInstanceKey` parameter.\n   * Variable updates can be delayed by listener-related processing; if processing exceeds the\n   * request timeout, this endpoint can return 504. Other gateway timeout causes are also\n   * possible. Retry with backoff and inspect listener worker availability and logs when this\n   * repeats.\n   *\n    *\n   * @example Create element instance variables\n   * ```ts\n   * async function createElementInstanceVariablesExample(elementInstanceKey: ElementInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.createElementInstanceVariables({\n   *     elementInstanceKey,\n   *     variables: { orderId: 'ORD-12345', status: 'processing' },\n   *   });\n   * }\n   * ```\n   * @operationId createElementInstanceVariables\n   * @tags Element instance\n   */\n  createElementInstanceVariables(input: createElementInstanceVariablesInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createElementInstanceVariables>>;\n  createElementInstanceVariables(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createElementInstanceVariables(this, arg, options);\n  }\n\n  /**\n   * Create a global-scoped cluster variable\n   *\n   * Create a global-scoped cluster variable.\n    *\n   * @example Create a global cluster variable\n   * ```ts\n   * async function createGlobalClusterVariableExample(name: ClusterVariableName) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createGlobalClusterVariable({\n   *     name,\n   *     value: { darkMode: true },\n   *   });\n   * \n   *   console.log(`Created: ${result.name}`);\n   * }\n   * ```\n   * @operationId createGlobalClusterVariable\n   * @tags Cluster Variable\n   */\n  createGlobalClusterVariable(input: createGlobalClusterVariableInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createGlobalClusterVariable>>;\n  createGlobalClusterVariable(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createGlobalClusterVariable(this, arg, options);\n  }\n\n  /**\n   * Create global user task listener\n   *\n   * Create a new global user task listener.\n    *\n   * @example Create a global task listener\n   * ```ts\n   * async function createGlobalTaskListenerExample(id: GlobalListenerId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createGlobalTaskListener({\n   *     id,\n   *     eventTypes: ['completing'],\n   *     type: 'audit-log-listener',\n   *   });\n   * \n   *   console.log(`Created listener: ${result.id}`);\n   * }\n   * ```\n   * @operationId createGlobalTaskListener\n   * @tags Global listener\n   */\n  createGlobalTaskListener(input: createGlobalTaskListenerInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createGlobalTaskListener>>;\n  createGlobalTaskListener(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createGlobalTaskListener(this, arg, options);\n  }\n\n  /**\n   * Create group\n   *\n   * Create a new group.\n   *\n   * The supplied `groupId` is validated against `^[a-zA-Z0-9_~@.+-]+$`\n   * (max 256 characters) by `IdentifierValidator.validateId` in the\n   * runtime. This strict validation applies wherever the Groups API\n   * is available: in OIDC deployments that set\n   * `camunda.security.authentication.oidc.groupsClaim` the Groups\n   * API (including this endpoint) is disabled entirely, so group\n   * CRUD never sees externally-minted IdP IDs. The BYOG relaxation\n   * only loosens validation when a group is referenced *as a member*\n   * of a role or tenant (`assignRoleToGroup`,\n   * `assignGroupToTenant`); group CRUD itself always uses the strict\n   * default-id regex. The constraint is not advertised on the\n   * `GroupId` schema so that the same schema can be reused at\n   * member-reference sites without falsely rejecting\n   * externally-minted IdP group IDs there.\n   *\n    *\n   * @example Create a group\n   * ```ts\n   * async function createGroupExample(groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createGroup({\n   *     groupId,\n   *     name: 'Engineering Team',\n   *   });\n   * \n   *   console.log(`Created group: ${result.groupId}`);\n   * }\n   * ```\n   * @operationId createGroup\n   * @tags Group\n   */\n  createGroup(input: createGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createGroup>>;\n  createGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createGroup(this, arg, options);\n  }\n\n  /**\n   * Create mapping rule\n   *\n   * Create a new mapping rule\n   *\n    *\n   * @example Create a mapping rule\n   * ```ts\n   * async function createMappingRuleExample(mappingRuleId: MappingRuleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createMappingRule({\n   *     mappingRuleId,\n   *     name: 'LDAP Group Mapping',\n   *     claimName: 'groups',\n   *     claimValue: 'engineering',\n   *   });\n   * \n   *   console.log(`Created mapping rule: ${result.mappingRuleId}`);\n   * }\n   * ```\n   * @operationId createMappingRule\n   * @tags Mapping rule\n   */\n  createMappingRule(input: createMappingRuleInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createMappingRule>>;\n  createMappingRule(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createMappingRule(this, arg, options);\n  }\n\n  /**\n   * Create process instance\n   *\n   * Creates and starts an instance of the specified process.\n   * The process definition to use to create the instance can be specified either using its unique key\n   * (as returned by Deploy resources), or using the BPMN process id and a version.\n   * If only the process definition id is given, the latest ACTIVE version is used.\n   * If no ACTIVE version exists, the request is rejected as not found.\n   *\n   * Waits for the completion of the process instance before returning a result\n   * when awaitCompletion is enabled.\n   *\n    *\n   * @example By ID\n   * ```ts\n   * async function createProcessInstanceByIdExample(processDefinitionId: ProcessDefinitionId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createProcessInstance({\n   *     processDefinitionId,\n   *     variables: {\n   *       orderId: 'ORD-12345',\n   *       amount: 99.95,\n   *     },\n   *   });\n   * \n   *   console.log(`Started process instance: ${result.processInstanceKey}`);\n   * }\n   * ```\n   * @example By key\n   * ```ts\n   * async function createProcessInstanceByKeyExample(processDefinitionKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Key from a previous API response (e.g. deployment)\n   *   const result = await camunda.createProcessInstance({\n   *     processDefinitionKey,\n   *     variables: {\n   *       orderId: 'ORD-12345',\n   *       amount: 99.95,\n   *     },\n   *   });\n   * \n   *   console.log(`Started process instance: ${result.processInstanceKey}`);\n   * }\n   * ```\n   * @operationId createProcessInstance\n   * @tags Process instance\n   */\n  createProcessInstance(input: createProcessInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createProcessInstance>>;\n  createProcessInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createProcessInstance(this, arg, options);\n  }\n\n  /**\n   * Create role\n   *\n   * Create a new role.\n    *\n   * @example Create a role\n   * ```ts\n   * async function createRoleExample(roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createRole({\n   *     roleId,\n   *     name: 'Process Admin',\n   *   });\n   * \n   *   console.log(`Created role: ${result.roleId}`);\n   * }\n   * ```\n   * @operationId createRole\n   * @tags Role\n   */\n  createRole(input: createRoleInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createRole>>;\n  createRole(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createRole(this, arg, options);\n  }\n\n  /**\n   * Create tenant\n   *\n   * Creates a new tenant.\n    *\n   * @example Create a tenant\n   * ```ts\n   * async function createTenantExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createTenant({\n   *     tenantId,\n   *     name: 'Customer Service',\n   *   });\n   * \n   *   console.log(`Created tenant: ${result.tenantId}`);\n   * }\n   * ```\n   * @operationId createTenant\n   * @tags Tenant\n   */\n  createTenant(input: createTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createTenant>>;\n  createTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createTenant(this, arg, options);\n  }\n\n  /**\n   * Create a tenant-scoped cluster variable\n   *\n   * Create a new cluster variable for the given tenant.\n    *\n   * @example Create a tenant cluster variable\n   * ```ts\n   * async function createTenantClusterVariableExample(tenantId: TenantId, name: ClusterVariableName) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createTenantClusterVariable({\n   *     tenantId,\n   *     name,\n   *     value: { region: 'us-east-1' },\n   *   });\n   * \n   *   console.log(`Created: ${result.name}`);\n   * }\n   * ```\n   * @operationId createTenantClusterVariable\n   * @tags Cluster Variable\n   */\n  createTenantClusterVariable(input: createTenantClusterVariableInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createTenantClusterVariable>>;\n  createTenantClusterVariable(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createTenantClusterVariable(this, arg, options);\n  }\n\n  /**\n   * Create user\n   *\n   * Create a new user.\n    *\n   * @example Create a user\n   * ```ts\n   * async function createUserExample(username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.createUser({\n   *     username,\n   *     name: 'Alice Smith',\n   *     email: 'alice@example.com',\n   *     password: 'secure-password-123',\n   *   });\n   * \n   *   console.log(`Created user: ${result.username}`);\n   * }\n   * ```\n   * @operationId createUser\n   * @tags User\n   */\n  createUser(input: createUserInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.createUser>>;\n  createUser(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.createUser(this, arg, options);\n  }\n\n  /**\n   * Delete authorization\n   *\n   * Deletes the authorization with the given key.\n    *\n   * @example Delete an authorization\n   * ```ts\n   * async function deleteAuthorizationExample(authorizationKey: AuthorizationKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteAuthorization({ authorizationKey });\n   * }\n   * ```\n   * @operationId deleteAuthorization\n   * @tags Authorization\n   */\n  deleteAuthorization(input: deleteAuthorizationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteAuthorization>>;\n  deleteAuthorization(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteAuthorization(this, arg, options);\n  }\n\n  /**\n   * Delete decision instance\n   *\n   * Delete all associated decision evaluations based on provided key.\n    *\n   * @example Delete a decision instance\n   * ```ts\n   * async function deleteDecisionInstanceExample(decisionEvaluationKey: DecisionEvaluationKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteDecisionInstance({ decisionEvaluationKey });\n   * }\n   * ```\n   * @operationId deleteDecisionInstance\n   * @tags Decision instance\n   */\n  deleteDecisionInstance(input: deleteDecisionInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteDecisionInstance>>;\n  deleteDecisionInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteDecisionInstance(this, arg, options);\n  }\n\n  /**\n   * Delete decision instances (batch)\n   *\n   * Delete multiple decision instances. This will delete the historic data from secondary storage.\n   * This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Delete decision instances in batch\n   * ```ts\n   * async function deleteDecisionInstancesBatchOperationExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.deleteDecisionInstancesBatchOperation({\n   *     filter: {},\n   *   });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId deleteDecisionInstancesBatchOperation\n   * @tags Decision instance\n   */\n  deleteDecisionInstancesBatchOperation(input: deleteDecisionInstancesBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteDecisionInstancesBatchOperation>>;\n  deleteDecisionInstancesBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteDecisionInstancesBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Delete document\n   *\n   * Delete a document from the Camunda 8 cluster.\n   *\n   * Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)\n   *\n    *\n   * @example Delete a document\n   * ```ts\n   * async function deleteDocumentExample(documentId: DocumentId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteDocument({ documentId });\n   * }\n   * ```\n   * @operationId deleteDocument\n   * @tags Document\n   */\n  deleteDocument(input: deleteDocumentInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteDocument>>;\n  deleteDocument(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteDocument(this, arg, options);\n  }\n\n  /**\n   * Delete a global-scoped cluster variable\n   *\n   * Delete a global-scoped cluster variable.\n    *\n   * @example Delete a global cluster variable\n   * ```ts\n   * async function deleteGlobalClusterVariableExample(name: ClusterVariableName) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteGlobalClusterVariable({ name });\n   * }\n   * ```\n   * @operationId deleteGlobalClusterVariable\n   * @tags Cluster Variable\n   */\n  deleteGlobalClusterVariable(input: deleteGlobalClusterVariableInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteGlobalClusterVariable>>;\n  deleteGlobalClusterVariable(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteGlobalClusterVariable(this, arg, options);\n  }\n\n  /**\n   * Delete global user task listener\n   *\n   * Deletes a global user task listener.\n    *\n   * @example Delete a global task listener\n   * ```ts\n   * async function deleteGlobalTaskListenerExample(id: GlobalListenerId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteGlobalTaskListener({\n   *     id,\n   *   });\n   * }\n   * ```\n   * @operationId deleteGlobalTaskListener\n   * @tags Global listener\n   */\n  deleteGlobalTaskListener(input: deleteGlobalTaskListenerInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteGlobalTaskListener>>;\n  deleteGlobalTaskListener(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteGlobalTaskListener(this, arg, options);\n  }\n\n  /**\n   * Delete group\n   *\n   * Deletes the group with the given ID.\n    *\n   * @example Delete a group\n   * ```ts\n   * async function deleteGroupExample(groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteGroup({ groupId });\n   * }\n   * ```\n   * @operationId deleteGroup\n   * @tags Group\n   */\n  deleteGroup(input: deleteGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteGroup>>;\n  deleteGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteGroup(this, arg, options);\n  }\n\n  /**\n   * Delete history backup\n   *\n   * Deletes the history backup with the given id, by deleting every snapshot that makes it\n   * up.\n   *\n   * Only available on clusters whose secondary storage is Elasticsearch or OpenSearch.\n   *\n    *\n   * @example Delete a history backup\n   * ```ts\n   * async function deleteHistoryBackupExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteHistoryBackup({ backupId: 100 });\n   * }\n   * ```\n   * @operationId deleteHistoryBackup\n   * @tags Backup\n   */\n  deleteHistoryBackup(input: deleteHistoryBackupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteHistoryBackup>>;\n  deleteHistoryBackup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteHistoryBackup(this, arg, options);\n  }\n\n  /**\n   * Delete a history backup across physical tenants\n   *\n   * Deletes the history backup with the given id from every physical tenant of the cluster, or from the one named by `physicalTenantId`. A tenant that does not hold the backup has already reached the requested end state, so it counts as deleted rather than as a failure.\n   *\n   * The request is all-or-nothing: a physical tenant the backup cannot be deleted from fails the whole request, and the deletions that already succeeded on other tenants are not undone. Narrow the request with `physicalTenantId` to delete from the tenants that can still be reached.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Only available on clusters whose secondary storage is Elasticsearch or OpenSearch. Use `DELETE /v2/backups/history/{backupId}` to act as a single physical tenant.\n    *\n   * @example Delete a history backup (cluster admin)\n   * ```ts\n   * async function deleteHistoryBackupAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Deletion fans out to every physical tenant (or a single one when\n   *   // `physicalTenantId` is given) and is not undone if a later tenant fails.\n   *   await camunda.deleteHistoryBackupAsClusterAdmin({ backupId: 100 });\n   * }\n   * ```\n   * @operationId deleteHistoryBackupAsClusterAdmin\n   * @tags Backup\n   */\n  deleteHistoryBackupAsClusterAdmin(input: deleteHistoryBackupAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteHistoryBackupAsClusterAdmin>>;\n  deleteHistoryBackupAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteHistoryBackupAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Delete a mapping rule\n   *\n   * Deletes the mapping rule with the given ID.\n   *\n    *\n   * @example Delete a mapping rule\n   * ```ts\n   * async function deleteMappingRuleExample(mappingRuleId: MappingRuleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteMappingRule({ mappingRuleId });\n   * }\n   * ```\n   * @operationId deleteMappingRule\n   * @tags Mapping rule\n   */\n  deleteMappingRule(input: deleteMappingRuleInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteMappingRule>>;\n  deleteMappingRule(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteMappingRule(this, arg, options);\n  }\n\n  /**\n   * Delete process instance\n   *\n   * Deletes a process instance. Only instances that are completed or terminated can be deleted.\n    *\n   * @example Delete a process instance\n   * ```ts\n   * async function deleteProcessInstanceExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteProcessInstance({ processInstanceKey });\n   * }\n   * ```\n   * @operationId deleteProcessInstance\n   * @tags Process instance\n   */\n  deleteProcessInstance(input: deleteProcessInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteProcessInstance>>;\n  deleteProcessInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteProcessInstance(this, arg, options);\n  }\n\n  /**\n   * Delete process instances (batch)\n   *\n   * Delete multiple process instances. This will delete the historic data from secondary storage.\n   * Only process instances in a final state (COMPLETED or TERMINATED) can be deleted.\n   * This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Delete process instances in batch\n   * ```ts\n   * async function deleteProcessInstancesBatchOperationExample(\n   *   processDefinitionKey: ProcessDefinitionKey\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.deleteProcessInstancesBatchOperation({\n   *     filter: {\n   *       processDefinitionKey,\n   *     },\n   *   });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId deleteProcessInstancesBatchOperation\n   * @tags Process instance\n   */\n  deleteProcessInstancesBatchOperation(input: deleteProcessInstancesBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteProcessInstancesBatchOperation>>;\n  deleteProcessInstancesBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteProcessInstancesBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Delete resource\n   *\n   * Deletes a deployed resource. This can be a process definition, decision requirements\n   * definition, or form definition deployed using the deploy resources endpoint. Specify the\n   * resource you want to delete in the `resourceKey` parameter.\n   *\n   * Once a resource has been deleted it cannot be recovered. If the resource needs to be\n   * available again, a new deployment of the resource is required.\n   *\n   * By default, only the resource itself is deleted from the runtime state. To also delete the\n   * historic data associated with a resource, set the `deleteHistory` flag in the request body\n   * to `true`. History deletion is supported for process definitions and decision requirements\n   * definitions; for other resource types (forms, generic resources) the flag is ignored and no\n   * history is deleted.\n   *\n   * The two supported types differ in how the history is removed. For a decision requirements\n   * definition the history is deleted asynchronously via a batch operation whose details are\n   * returned in the `batchOperation` field of the response. For a process definition that still\n   * exists in the runtime state, the definition first drains its running instances and its\n   * history is deleted asynchronously once the definition is fully removed cluster-wide; no batch\n   * operation is returned in the response. If the process definition has already been removed\n   * from the runtime state and the deletion is later re-triggered with `deleteHistory` set to\n   * `true`, a batch operation is created immediately and returned in the `batchOperation` field.\n    *\n   * @example Delete a resource\n   * ```ts\n   * async function deleteResourceExample(resourceKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Use a process definition key as a resource key for deletion\n   *   await camunda.deleteResource({\n   *     resourceKey,\n   *   });\n   * }\n   * ```\n   * @operationId deleteResource\n   * @tags Resource\n   */\n  deleteResource(input: deleteResourceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteResource>>;\n  deleteResource(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteResource(this, arg, options);\n  }\n\n  /**\n   * Delete role\n   *\n   * Deletes the role with the given ID.\n    *\n   * @example Delete a role\n   * ```ts\n   * async function deleteRoleExample(roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteRole({ roleId });\n   * }\n   * ```\n   * @operationId deleteRole\n   * @tags Role\n   */\n  deleteRole(input: deleteRoleInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteRole>>;\n  deleteRole(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteRole(this, arg, options);\n  }\n\n  /**\n   * Delete runtime backup\n   *\n   * Deletes the runtime backup with the given id.\n    *\n   * @example Delete a runtime backup\n   * ```ts\n   * async function deleteRuntimeBackupExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteRuntimeBackup({ backupId: 100 });\n   * }\n   * ```\n   * @operationId deleteRuntimeBackup\n   * @tags Backup\n   */\n  deleteRuntimeBackup(input: deleteRuntimeBackupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteRuntimeBackup>>;\n  deleteRuntimeBackup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteRuntimeBackup(this, arg, options);\n  }\n\n  /**\n   * Delete a runtime backup across physical tenants\n   *\n   * Deletes the runtime backup with the given id from every physical tenant of the cluster, or from the one named by `physicalTenantId`. A tenant that does not hold the backup has already reached the requested end state, so it counts as deleted rather than as a failure — the same as deleting an unknown backup id through the per-physical-tenant endpoint.\n   *\n   * The request is all-or-nothing: a physical tenant the backup cannot be deleted from fails the whole request, and the deletions that already succeeded on other tenants are not undone. Narrow the request with `physicalTenantId` to delete from the tenants that can still be reached.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Use `DELETE /v2/backups/runtime/{backupId}` to act as a single physical tenant.\n    *\n   * @example Delete a runtime backup (cluster admin)\n   * ```ts\n   * async function deleteRuntimeBackupAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Deletion fans out to every physical tenant (or a single one when\n   *   // `physicalTenantId` is given) and is not undone if a later tenant fails.\n   *   await camunda.deleteRuntimeBackupAsClusterAdmin({ backupId: 100 });\n   * }\n   * ```\n   * @operationId deleteRuntimeBackupAsClusterAdmin\n   * @tags Backup\n   */\n  deleteRuntimeBackupAsClusterAdmin(input: deleteRuntimeBackupAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteRuntimeBackupAsClusterAdmin>>;\n  deleteRuntimeBackupAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteRuntimeBackupAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Delete runtime backup state\n   *\n   * Resets the runtime backup state of every partition of the physical tenant, clearing\n   * all checkpoint info, backup info, checkpoint metadata, and backup ranges. Used when\n   * switching backup stores.\n   *\n    *\n   * @example Delete the runtime backup state\n   * ```ts\n   * async function deleteRuntimeBackupStateExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Clears all checkpoint info, backup info, checkpoint metadata, and backup\n   *   // ranges on every partition. Used when switching backup stores.\n   *   await camunda.deleteRuntimeBackupState();\n   * }\n   * ```\n   * @operationId deleteRuntimeBackupState\n   * @tags Backup\n   */\n  deleteRuntimeBackupState(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteRuntimeBackupState>>;\n  deleteRuntimeBackupState(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteRuntimeBackupState(this, options);\n  }\n\n  /**\n   * Delete runtime backup state across physical tenants\n   *\n   * Resets the runtime backup state of every partition of every physical tenant of the cluster, or of the one named by `physicalTenantId`, clearing all checkpoint info, backup info, checkpoint metadata, and backup ranges. Used when switching backup stores.\n   *\n   * The request is all-or-nothing: a physical tenant whose state cannot be reset fails the whole request, and the resets that already succeeded on other tenants are not undone. Narrow the request with `physicalTenantId` to reset the tenants that can still be reached.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Use `DELETE /v2/backups/runtime/state` to act as a single physical tenant.\n    *\n   * @example Delete the runtime backup state (cluster admin)\n   * ```ts\n   * async function deleteRuntimeBackupStateAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Clears all checkpoint info, backup info, checkpoint metadata, and backup\n   *   // ranges on every partition of every targeted physical tenant (or a single one\n   *   // when `physicalTenantId` is given). Used when switching backup stores.\n   *   await camunda.deleteRuntimeBackupStateAsClusterAdmin({});\n   * }\n   * ```\n   * @operationId deleteRuntimeBackupStateAsClusterAdmin\n   * @tags Backup\n   */\n  deleteRuntimeBackupStateAsClusterAdmin(input: deleteRuntimeBackupStateAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteRuntimeBackupStateAsClusterAdmin>>;\n  deleteRuntimeBackupStateAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteRuntimeBackupStateAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Delete tenant\n   *\n   * Deletes an existing tenant.\n    *\n   * @example Delete a tenant\n   * ```ts\n   * async function deleteTenantExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteTenant({ tenantId });\n   * }\n   * ```\n   * @operationId deleteTenant\n   * @tags Tenant\n   */\n  deleteTenant(input: deleteTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteTenant>>;\n  deleteTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteTenant(this, arg, options);\n  }\n\n  /**\n   * Delete a tenant-scoped cluster variable\n   *\n   * Delete a tenant-scoped cluster variable.\n    *\n   * @example Delete a tenant cluster variable\n   * ```ts\n   * async function deleteTenantClusterVariableExample(tenantId: TenantId, name: ClusterVariableName) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteTenantClusterVariable({\n   *     tenantId,\n   *     name,\n   *   });\n   * }\n   * ```\n   * @operationId deleteTenantClusterVariable\n   * @tags Cluster Variable\n   */\n  deleteTenantClusterVariable(input: deleteTenantClusterVariableInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteTenantClusterVariable>>;\n  deleteTenantClusterVariable(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteTenantClusterVariable(this, arg, options);\n  }\n\n  /**\n   * Delete user\n   *\n   * Deletes a user.\n    *\n   * @example Delete a user\n   * ```ts\n   * async function deleteUserExample(username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.deleteUser({ username });\n   * }\n   * ```\n   * @operationId deleteUser\n   * @tags User\n   */\n  deleteUser(input: deleteUserInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.deleteUser>>;\n  deleteUser(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.deleteUser(this, arg, options);\n  }\n\n  /**\n   * Evaluate root level conditional start events\n   *\n   * Evaluates root-level conditional start events for process definitions.\n   * If the evaluation is successful, it will return the keys of all created process instances, along with their associated process definition key.\n   * Multiple root-level conditional start events of the same process definition can trigger if their conditions evaluate to true.\n   *\n    *\n   * @example Evaluate conditionals\n   * ```ts\n   * async function evaluateConditionalsExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.evaluateConditionals({\n   *     variables: { orderReady: true },\n   *     tenantId,\n   *   });\n   * \n   *   console.log(`Evaluated conditionals: ${JSON.stringify(result)}`);\n   * }\n   * ```\n   * @operationId evaluateConditionals\n   * @tags Conditional\n   */\n  evaluateConditionals(input: evaluateConditionalsInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.evaluateConditionals>>;\n  evaluateConditionals(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.evaluateConditionals(this, arg, options);\n  }\n\n  /**\n   * Evaluate decision\n   *\n   * Evaluates a decision.\n   * You specify the decision to evaluate either by using its unique key (as returned by\n   * DeployResource), or using the decision ID. When using the decision ID, the latest deployed\n   * version of the decision is used.\n   *\n    *\n   * @example By ID\n   * ```ts\n   * async function evaluateDecisionByIdExample(decisionDefinitionId: DecisionDefinitionId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.evaluateDecision({\n   *     decisionDefinitionId,\n   *     variables: {\n   *       amount: 1000,\n   *       invoiceCategory: 'Misc',\n   *     },\n   *   });\n   * \n   *   console.log(`Decision: ${result.decisionDefinitionId}`);\n   *   console.log(`Output: ${result.output}`);\n   * }\n   * ```\n   * @example By key\n   * ```ts\n   * async function evaluateDecisionByKeyExample(decisionDefinitionKey: DecisionDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.evaluateDecision({\n   *     decisionDefinitionKey,\n   *     variables: {\n   *       amount: 1000,\n   *       invoiceCategory: 'Misc',\n   *     },\n   *   });\n   * \n   *   console.log(`Decision output: ${result.output}`);\n   * }\n   * ```\n   * @operationId evaluateDecision\n   * @tags Decision definition\n   */\n  evaluateDecision(input: evaluateDecisionInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.evaluateDecision>>;\n  evaluateDecision(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.evaluateDecision(this, arg, options);\n  }\n\n  /**\n   * Evaluate an expression\n   *\n   * Evaluates a FEEL expression and returns the result. Supports references to tenant scoped\n   * cluster variables when a tenant ID is provided. Optionally, provide a `scopeKey` to make the\n   * variables of a specific process instance or element instance visible while evaluating the\n   * expression.\n   *\n    *\n   * @example Evaluate an expression\n   * ```ts\n   * async function evaluateExpressionExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.evaluateExpression({\n   *     expression: '= x + y',\n   *     variables: { x: 10, y: 20 },\n   *   });\n   * \n   *   console.log(`Result: ${result.result}`);\n   * }\n   * ```\n   * @operationId evaluateExpression\n   * @tags Expression\n   */\n  evaluateExpression(input: evaluateExpressionInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.evaluateExpression>>;\n  evaluateExpression(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.evaluateExpression(this, arg, options);\n  }\n\n  /**\n   * Fail job\n   *\n   * Mark the job as failed.\n   *\n    *\n   * @example Fail a job with retry\n   * ```ts\n   * async function failJobExample(jobKey: JobKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.failJob({\n   *     jobKey,\n   *     retries: 2,\n   *     errorMessage: 'Payment gateway timeout',\n   *     retryBackOff: 5000,\n   *   });\n   * }\n   * ```\n   * @operationId failJob\n   * @tags Job\n   */\n  failJob(input: failJobInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.failJob>>;\n  failJob(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.failJob(this, arg, options);\n  }\n\n  /**\n   * Get agent definition\n   *\n   * Returns an agent definition by key.\n    *\n   * @example Get an agent definition\n   * ```ts\n   * async function getAgentDefinitionExample(agentDefinitionKey: AgentDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const definition = await camunda.getAgentDefinition(\n   *     { agentDefinitionKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Name: ${definition.name}`);\n   *   console.log(`Type: ${definition.agentType}`);\n   *   console.log(`Element: ${definition.elementId}`);\n   * }\n   * ```\n   * @operationId getAgentDefinition\n   * @tags Agent definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getAgentDefinition(input: getAgentDefinitionInput, /** Management of eventual consistency **/ consistencyManagement: getAgentDefinitionConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getAgentDefinition>>;\n  getAgentDefinition(arg: any, /** Management of eventual consistency **/ consistencyManagement: getAgentDefinitionConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getAgentDefinition(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get agent instance\n   *\n   * Returns agent instance as JSON.\n    *\n   * @example Get an agent instance\n   * ```ts\n   * async function getAgentInstanceExample(agentInstanceKey: AgentInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const instance = await camunda.getAgentInstance(\n   *     { agentInstanceKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Status: ${instance.status}`);\n   *   console.log(`Element: ${instance.elementId}`);\n   * }\n   * ```\n   * @operationId getAgentInstance\n   * @tags Agent instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getAgentInstance(input: getAgentInstanceInput, /** Management of eventual consistency **/ consistencyManagement: getAgentInstanceConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getAgentInstance>>;\n  getAgentInstance(arg: any, /** Management of eventual consistency **/ consistencyManagement: getAgentInstanceConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getAgentInstance(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get audit log\n   *\n   * Get an audit log entry by auditLogKey.\n    *\n   * @example Get an audit log entry\n   * ```ts\n   * async function getAuditLogExample(auditLogKey: AuditLogKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const log = await camunda.getAuditLog({ auditLogKey }, { consistency: { waitUpToMs: 5000 } });\n   * \n   *   console.log(`Audit log: ${log.operationType}`);\n   * }\n   * ```\n   * @operationId getAuditLog\n   * @tags Audit Log\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getAuditLog(input: getAuditLogInput, /** Management of eventual consistency **/ consistencyManagement: getAuditLogConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getAuditLog>>;\n  getAuditLog(arg: any, /** Management of eventual consistency **/ consistencyManagement: getAuditLogConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getAuditLog(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get current user\n   *\n   * Retrieves the current authenticated user.\n    *\n   * @example Get authentication info\n   * ```ts\n   * async function getAuthenticationExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const user = await camunda.getAuthentication();\n   * \n   *   console.log(`Authenticated as: ${user.username}`);\n   * }\n   * ```\n   * @operationId getAuthentication\n   * @tags Authentication\n   */\n  getAuthentication(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getAuthentication>>;\n  getAuthentication(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getAuthentication(this, options);\n  }\n\n  /**\n   * Get authorization\n   *\n   * Get authorization by the given key.\n    *\n   * @example Get an authorization\n   * ```ts\n   * async function getAuthorizationExample(authorizationKey: AuthorizationKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const authorization = await camunda.getAuthorization(\n   *     { authorizationKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Owner: ${authorization.ownerId} (${authorization.ownerType})`);\n   * }\n   * ```\n   * @operationId getAuthorization\n   * @tags Authorization\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getAuthorization(input: getAuthorizationInput, /** Management of eventual consistency **/ consistencyManagement: getAuthorizationConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getAuthorization>>;\n  getAuthorization(arg: any, /** Management of eventual consistency **/ consistencyManagement: getAuthorizationConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getAuthorization(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get batch operation\n   *\n   * Get batch operation by key.\n    *\n   * @example Get a batch operation\n   * ```ts\n   * async function getBatchOperationExample(batchOperationKey: BatchOperationKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const batch = await camunda.getBatchOperation(\n   *     { batchOperationKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Batch: ${batch.batchOperationType} (${batch.state})`);\n   * }\n   * ```\n   * @operationId getBatchOperation\n   * @tags Batch operation\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getBatchOperation(input: getBatchOperationInput, /** Management of eventual consistency **/ consistencyManagement: getBatchOperationConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getBatchOperation>>;\n  getBatchOperation(arg: any, /** Management of eventual consistency **/ consistencyManagement: getBatchOperationConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getBatchOperation(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get exporting status of the whole cluster\n   *\n   * Returns the exporting status of the whole cluster, folded over the exporting status of every physical tenant. Only `PAUSED` and `SOFT_PAUSED` confirm that exporting is paused cluster-wide; every other value means at least one physical tenant is not paused, so callers should keep polling. A physical tenant that itself reports `MIXED` makes the whole cluster `MIXED`.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here.\n    *\n   * @example Get cluster exporting status\n   * ```ts\n   * async function getClusterExportingStatusExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Reports the aggregated exporting status of the whole cluster — useful to\n   *   // confirm exporting has paused everywhere before taking a cluster-wide backup.\n   *   const { status } = await camunda.getClusterExportingStatus();\n   *   console.log(`Cluster exporting status: ${status}`);\n   * }\n   * ```\n   * @operationId getClusterExportingStatus\n   * @tags Exporting\n   */\n  getClusterExportingStatus(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getClusterExportingStatus>>;\n  getClusterExportingStatus(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getClusterExportingStatus(this, options);\n  }\n\n  /**\n   * Report the cluster's current leadership balance\n   *\n   * Reports whether the cluster is currently balanced, the current leadership state of every partition, and what became of the last rebalance to finish. The last completed rebalance is held in memory by the coordinating broker, so none will be reported if the coordinator has moved or restarted since the last rebalance.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here.\n    *\n   * @example Get cluster rebalance status\n   * ```ts\n   * async function getClusterRebalanceExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const balance = await camunda.getClusterRebalance();\n   * \n   *   console.log(`Cluster balance state: ${balance.state}`);\n   *   for (const partition of balance.partitions) {\n   *     console.log(\n   *       `  Partition ${partition.partitionId}: state=${partition.state}, currentLeader=${partition.currentLeader}, desiredLeader=${partition.desiredLeader}`\n   *     );\n   *   }\n   *   if (balance.runningRebalance) {\n   *     console.log(`Running rebalance id=${balance.runningRebalance.rebalanceId}`);\n   *   }\n   * }\n   * ```\n   * @operationId getClusterRebalance\n   * @tags Cluster\n   */\n  getClusterRebalance(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getClusterRebalance>>;\n  getClusterRebalance(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getClusterRebalance(this, options);\n  }\n\n  /**\n   * Get the status of the whole cluster\n   *\n   * Checks the health status of the whole cluster, aggregated over all physical tenants. Returns `HEALTHY` when every physical tenant is healthy, `DOWN` when no physical tenant can process work, and `DEGRADED` in every other case. No per-tenant detail is reported; use `GET /cluster/v2/topology` for that.\n   *\n   * This endpoint is public and requires no authentication, unlike `PATCH /cluster/v2/mode` below, which needs cluster-admin credentials.\n    *\n   * @example Get cluster status\n   * ```ts\n   * async function getClusterStatusExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const status = await camunda.getClusterStatus();\n   * \n   *   console.log(`Cluster status: ${status.status}`);\n   * }\n   * ```\n   * @operationId getClusterStatus\n   * @tags Cluster\n   */\n  getClusterStatus(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getClusterStatus>>;\n  getClusterStatus(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getClusterStatus(this, options);\n  }\n\n  /**\n   * Get the topology of the whole cluster\n   *\n   * Obtains the topology of the whole cluster, aggregated over all physical tenants. Cluster-level information is reported once; partition layout, replication and per-partition role, health and state are reported per physical tenant.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Use `GET /v2/topology` for the topology of a single physical tenant.\n    *\n   * @example Get cluster topology (v2)\n   * ```ts\n   * async function getClusterTopologyExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Returns the full cluster topology: brokers, physical tenants (in a\n   *   // multi-tenant cluster), cluster size, and gateway version.\n   *   const topology = await camunda.getClusterTopology();\n   * \n   *   console.log(\n   *     `Cluster ${topology.clusterId} — ${topology.clusterSize} broker(s), gateway ${topology.gatewayVersion}`\n   *   );\n   *   for (const broker of topology.brokers) {\n   *     console.log(`  Broker ${broker.brokerId}: ${broker.host}:${broker.port} (${broker.version})`);\n   *   }\n   *   for (const tenant of topology.physicalTenants) {\n   *     console.log(\n   *       `  Physical tenant ${tenant.physicalTenantId}: ${tenant.partitionsCount} partition(s), replication ${tenant.replicationFactor}`\n   *     );\n   *   }\n   * }\n   * ```\n   * @operationId getClusterTopology\n   * @tags Cluster\n   */\n  getClusterTopology(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getClusterTopology>>;\n  getClusterTopology(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getClusterTopology(this, options);\n  }\n\n  /**\n   * Get the upgrade-readiness status of the whole cluster\n   *\n   * Reports one overall upgrade-readiness status for the whole cluster, folded over every physical tenant and condition. `MIGRATED` only once every known condition has migrated for every known physical tenant; `MIGRATION_IN_PROGRESS` when at least one is confirmed not yet migrated; `UNKNOWN` otherwise (including before anything has been reported yet). No per-tenant or per-condition detail is reported here; see the `upgradeReadiness` actuator endpoint for that.\n    *\n   * @example Get cluster upgrade-readiness status\n   * ```ts\n   * async function getClusterUpgradeStatusExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const upgradeStatus = await camunda.getClusterUpgradeStatus();\n   * \n   *   console.log(`Cluster upgrade-readiness status: ${upgradeStatus.status}`);\n   * }\n   * ```\n   * @operationId getClusterUpgradeStatus\n   * @tags Cluster\n   */\n  getClusterUpgradeStatus(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getClusterUpgradeStatus>>;\n  getClusterUpgradeStatus(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getClusterUpgradeStatus(this, options);\n  }\n\n  /**\n   * Get decision definition\n   *\n   * Returns a decision definition by key.\n    *\n   * @example Get a decision definition\n   * ```ts\n   * async function getDecisionDefinitionExample(decisionDefinitionKey: DecisionDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const definition = await camunda.getDecisionDefinition(\n   *     { decisionDefinitionKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Decision: ${definition.decisionDefinitionId}`);\n   *   console.log(`Version: ${definition.version}`);\n   * }\n   * ```\n   * @operationId getDecisionDefinition\n   * @tags Decision definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getDecisionDefinition(input: getDecisionDefinitionInput, /** Management of eventual consistency **/ consistencyManagement: getDecisionDefinitionConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getDecisionDefinition>>;\n  getDecisionDefinition(arg: any, /** Management of eventual consistency **/ consistencyManagement: getDecisionDefinitionConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getDecisionDefinition(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get decision definition XML\n   *\n   * Returns decision definition as XML.\n    *\n   * @example Get decision definition XML\n   * ```ts\n   * async function getDecisionDefinitionXmlExample(decisionDefinitionKey: DecisionDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const xml = await camunda.getDecisionDefinitionXml(\n   *     { decisionDefinitionKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`XML length: ${JSON.stringify(xml).length}`);\n   * }\n   * ```\n   * @operationId getDecisionDefinitionXML\n   * @tags Decision definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getDecisionDefinitionXml(input: getDecisionDefinitionXmlInput, /** Management of eventual consistency **/ consistencyManagement: getDecisionDefinitionXmlConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getDecisionDefinitionXml>>;\n  getDecisionDefinitionXml(arg: any, /** Management of eventual consistency **/ consistencyManagement: getDecisionDefinitionXmlConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getDecisionDefinitionXml(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get decision instance\n   *\n   * Returns a decision instance.\n    *\n   * @example Get a decision instance\n   * ```ts\n   * async function getDecisionInstanceExample(\n   *   decisionEvaluationInstanceKey: DecisionEvaluationInstanceKey\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const instance = await camunda.getDecisionInstance(\n   *     { decisionEvaluationInstanceKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Decision: ${instance.decisionDefinitionId}`);\n   * }\n   * ```\n   * @operationId getDecisionInstance\n   * @tags Decision instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getDecisionInstance(input: getDecisionInstanceInput, /** Management of eventual consistency **/ consistencyManagement: getDecisionInstanceConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getDecisionInstance>>;\n  getDecisionInstance(arg: any, /** Management of eventual consistency **/ consistencyManagement: getDecisionInstanceConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getDecisionInstance(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get decision requirements\n   *\n   * Returns Decision Requirements as JSON.\n    *\n   * @example Get decision requirements\n   * ```ts\n   * async function getDecisionRequirementsExample(decisionRequirementsKey: DecisionRequirementsKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const requirements = await camunda.getDecisionRequirements(\n   *     { decisionRequirementsKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Requirements: ${requirements.decisionRequirementsId}`);\n   * }\n   * ```\n   * @operationId getDecisionRequirements\n   * @tags Decision requirements\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getDecisionRequirements(input: getDecisionRequirementsInput, /** Management of eventual consistency **/ consistencyManagement: getDecisionRequirementsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getDecisionRequirements>>;\n  getDecisionRequirements(arg: any, /** Management of eventual consistency **/ consistencyManagement: getDecisionRequirementsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getDecisionRequirements(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get decision requirements XML\n   *\n   * Returns decision requirements as XML.\n    *\n   * @example Get decision requirements XML\n   * ```ts\n   * async function getDecisionRequirementsXmlExample(decisionRequirementsKey: DecisionRequirementsKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const xml = await camunda.getDecisionRequirementsXml(\n   *     { decisionRequirementsKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`XML length: ${JSON.stringify(xml).length}`);\n   * }\n   * ```\n   * @operationId getDecisionRequirementsXML\n   * @tags Decision requirements\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getDecisionRequirementsXml(input: getDecisionRequirementsXmlInput, /** Management of eventual consistency **/ consistencyManagement: getDecisionRequirementsXmlConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getDecisionRequirementsXml>>;\n  getDecisionRequirementsXml(arg: any, /** Management of eventual consistency **/ consistencyManagement: getDecisionRequirementsXmlConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getDecisionRequirementsXml(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Download document\n   *\n   * Download a document from the Camunda 8 cluster.\n   *\n   * Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)\n   *\n    *\n   * @example Download a document\n   * ```ts\n   * async function getDocumentExample(documentId: DocumentId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.getDocument({ documentId });\n   * \n   *   console.log(`Downloaded document: ${documentId}`);\n   * }\n   * ```\n   * @operationId getDocument\n   * @tags Document\n   */\n  getDocument(input: getDocumentInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getDocument>>;\n  getDocument(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getDocument(this, arg, options);\n  }\n\n  /**\n   * Get element instance\n   *\n   * Returns element instance as JSON.\n    *\n   * @example Get an element instance\n   * ```ts\n   * async function getElementInstanceExample(elementInstanceKey: ElementInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const element = await camunda.getElementInstance(\n   *     { elementInstanceKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Element: ${element.elementId} (${element.type})`);\n   * }\n   * ```\n   * @operationId getElementInstance\n   * @tags Element instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getElementInstance(input: getElementInstanceInput, /** Management of eventual consistency **/ consistencyManagement: getElementInstanceConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getElementInstance>>;\n  getElementInstance(arg: any, /** Management of eventual consistency **/ consistencyManagement: getElementInstanceConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getElementInstance(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get exporting status\n   *\n   * Returns the exporting status of the physical tenant, aggregated over every replica of\n   * every one of its partitions.\n   *\n   * Because pause and resume are applied to all replicas, the status is only a single phase\n   * if every replica reports that phase; otherwise it is `MIXED`, which means a pause or\n   * resume is still in flight or was only partially applied. Backup tooling should treat\n   * only `PAUSED` and `SOFT_PAUSED` as confirmation that exporting is paused.\n   *\n    *\n   * @example Get exporting status\n   * ```ts\n   * async function getExportingStatusExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Reports the aggregated exporting status of the physical tenant — useful to\n   *   // confirm exporting has actually paused before taking a backup, and that it\n   *   // has resumed afterwards.\n   *   const { status } = await camunda.getExportingStatus();\n   *   console.log(`Exporting status: ${status}`);\n   * }\n   * ```\n   * @operationId getExportingStatus\n   * @tags Exporting\n   */\n  getExportingStatus(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getExportingStatus>>;\n  getExportingStatus(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getExportingStatus(this, options);\n  }\n\n  /**\n   * Get form by key\n   *\n   * Get a form by its unique form key.\n   *\n    *\n   * @example Get a form by key\n   * ```ts\n   * async function getFormByKeyExample(formKey: FormKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const form = await camunda.getFormByKey(\n   *     {\n   *       formKey,\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Form: ${form.formId}, version: ${form.version}`);\n   * }\n   * ```\n   * @operationId getFormByKey\n   * @tags Form\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getFormByKey(input: getFormByKeyInput, /** Management of eventual consistency **/ consistencyManagement: getFormByKeyConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getFormByKey>>;\n  getFormByKey(arg: any, /** Management of eventual consistency **/ consistencyManagement: getFormByKeyConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getFormByKey(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get a global-scoped cluster variable\n   *\n   * Get a global-scoped cluster variable.\n    *\n   * @example Get a global cluster variable\n   * ```ts\n   * async function getGlobalClusterVariableExample(name: ClusterVariableName) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const variable = await camunda.getGlobalClusterVariable(\n   *     { name },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`${variable.name} = ${variable.value}`);\n   * }\n   * ```\n   * @operationId getGlobalClusterVariable\n   * @tags Cluster Variable\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getGlobalClusterVariable(input: getGlobalClusterVariableInput, /** Management of eventual consistency **/ consistencyManagement: getGlobalClusterVariableConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getGlobalClusterVariable>>;\n  getGlobalClusterVariable(arg: any, /** Management of eventual consistency **/ consistencyManagement: getGlobalClusterVariableConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getGlobalClusterVariable(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Global job statistics\n   *\n   * Returns global aggregated counts for jobs. Filter by the creation time window (required) and optionally by jobType.\n   *\n    *\n   * @example Get global job statistics\n   * ```ts\n   * async function getGlobalJobStatisticsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getGlobalJobStatistics(\n   *     {\n   *       from: '2025-01-01T00:00:00Z',\n   *       to: '2025-12-31T23:59:59Z',\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Statistics retrieved: ${JSON.stringify(result)}`);\n   * }\n   * ```\n   * @operationId getGlobalJobStatistics\n   * @tags Job\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getGlobalJobStatistics(input: getGlobalJobStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getGlobalJobStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getGlobalJobStatistics>>;\n  getGlobalJobStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getGlobalJobStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getGlobalJobStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get global user task listener\n   *\n   * Get a global user task listener by its id.\n    *\n   * @example Get a global task listener\n   * ```ts\n   * async function getGlobalTaskListenerExample(id: GlobalListenerId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const listener = await camunda.getGlobalTaskListener(\n   *     { id },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Listener: ${listener.type} (${listener.eventTypes})`);\n   * }\n   * ```\n   * @operationId getGlobalTaskListener\n   * @tags Global listener\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getGlobalTaskListener(input: getGlobalTaskListenerInput, /** Management of eventual consistency **/ consistencyManagement: getGlobalTaskListenerConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getGlobalTaskListener>>;\n  getGlobalTaskListener(arg: any, /** Management of eventual consistency **/ consistencyManagement: getGlobalTaskListenerConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getGlobalTaskListener(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get group\n   *\n   * Get a group by its ID.\n    *\n   * @example Get a group\n   * ```ts\n   * async function getGroupExample(groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const group = await camunda.getGroup({ groupId }, { consistency: { waitUpToMs: 5000 } });\n   * \n   *   console.log(`Group: ${group.name}`);\n   * }\n   * ```\n   * @operationId getGroup\n   * @tags Group\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getGroup(input: getGroupInput, /** Management of eventual consistency **/ consistencyManagement: getGroupConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getGroup>>;\n  getGroup(arg: any, /** Management of eventual consistency **/ consistencyManagement: getGroupConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getGroup(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get history backup\n   *\n   * Returns detailed status of the history backup with the given id.\n   *\n   * Only available on clusters whose secondary storage is Elasticsearch or OpenSearch.\n   *\n    *\n   * @example Get a history backup\n   * ```ts\n   * async function getHistoryBackupExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const backup = await camunda.getHistoryBackup({ backupId: 100 });\n   * \n   *   // The aggregated state is derived from the state of every expected snapshot.\n   *   console.log(`History backup ${backup.backupId}: ${backup.state}`);\n   * }\n   * ```\n   * @operationId getHistoryBackup\n   * @tags Backup\n   */\n  getHistoryBackup(input: getHistoryBackupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getHistoryBackup>>;\n  getHistoryBackup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getHistoryBackup(this, arg, options);\n  }\n\n  /**\n   * Get a history backup across physical tenants\n   *\n   * Reports what every physical tenant of the cluster, or the one named by `physicalTenantId`, holds for the given backup id. There is no aggregated cluster-level state: a tenant that was reached and does not hold this backup reports `NOT_FOUND`, which is a successful observation rather than a failure.\n   *\n   * The request is all-or-nothing: a physical tenant whose state cannot be read fails the whole request. Narrow the request with `physicalTenantId` to read the tenants that can still be reached.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Only available on clusters whose secondary storage is Elasticsearch or OpenSearch. Use `GET /v2/backups/history/{backupId}` to act as a single physical tenant.\n    *\n   * @example Get a history backup (cluster admin)\n   * ```ts\n   * async function getHistoryBackupAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Looking a backup id up directly lists every targeted physical tenant,\n   *   // including the ones reporting `NOT_FOUND` — a backup that only some tenants\n   *   // hold is a supported outcome.\n   *   const backup = await camunda.getHistoryBackupAsClusterAdmin({ backupId: 100 });\n   * \n   *   console.log(`Cluster history backup ${backup.backupId}:`);\n   *   for (const tenant of backup.physicalTenants) {\n   *     console.log(`  [${tenant.physicalTenantId}] ${tenant.state}`);\n   *   }\n   * }\n   * ```\n   * @operationId getHistoryBackupAsClusterAdmin\n   * @tags Backup\n   */\n  getHistoryBackupAsClusterAdmin(input: getHistoryBackupAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getHistoryBackupAsClusterAdmin>>;\n  getHistoryBackupAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getHistoryBackupAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Get incident\n   *\n   * Returns incident as JSON.\n   *\n    *\n   * @example Get an incident\n   * ```ts\n   * async function getIncidentExample(incidentKey: IncidentKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const incident = await camunda.getIncident(\n   *     { incidentKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Type: ${incident.errorType}`);\n   *   console.log(`State: ${incident.state}`);\n   *   console.log(`Message: ${incident.errorMessage}`);\n   * }\n   * ```\n   * @operationId getIncident\n   * @tags Incident\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getIncident(input: getIncidentInput, /** Management of eventual consistency **/ consistencyManagement: getIncidentConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getIncident>>;\n  getIncident(arg: any, /** Management of eventual consistency **/ consistencyManagement: getIncidentConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getIncident(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get error metrics for a job type\n   *\n   * Returns aggregated metrics per error for the given jobType.\n   *\n    *\n   * @example Get job error statistics\n   * ```ts\n   * async function getJobErrorStatisticsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getJobErrorStatistics(\n   *     {\n   *       filter: {\n   *         from: '2025-01-01T00:00:00Z',\n   *         to: '2025-12-31T23:59:59Z',\n   *         jobType: 'payment-processing',\n   *       },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(`Error: ${stat.errorMessage}, workers: ${stat.workers}`);\n   *   }\n   * }\n   * ```\n   * @operationId getJobErrorStatistics\n   * @tags Job\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getJobErrorStatistics(input: getJobErrorStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getJobErrorStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getJobErrorStatistics>>;\n  getJobErrorStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getJobErrorStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getJobErrorStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get time-series metrics for a job type\n   *\n   * Returns a list of time-bucketed metrics ordered ascending by time.\n   * The `from` and `to` fields select the time window of interest.\n   * Each item in the response corresponds to one time bucket of the requested resolution.\n   *\n    *\n   * @example Get job time series statistics\n   * ```ts\n   * async function getJobTimeSeriesStatisticsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getJobTimeSeriesStatistics(\n   *     {\n   *       filter: {\n   *         from: '2025-01-01T00:00:00Z',\n   *         to: '2025-12-31T23:59:59Z',\n   *         jobType: 'payment-processing',\n   *       },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const point of result.items ?? []) {\n   *     console.log(`Time: ${point.time}, created: ${point.created.count}`);\n   *   }\n   * }\n   * ```\n   * @operationId getJobTimeSeriesStatistics\n   * @tags Job\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getJobTimeSeriesStatistics(input: getJobTimeSeriesStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getJobTimeSeriesStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getJobTimeSeriesStatistics>>;\n  getJobTimeSeriesStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getJobTimeSeriesStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getJobTimeSeriesStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get job statistics by type\n   *\n   * Get statistics about jobs, grouped by job type.\n   *\n    *\n   * @example Get job type statistics\n   * ```ts\n   * async function getJobTypeStatisticsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getJobTypeStatistics({}, { consistency: { waitUpToMs: 5000 } });\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(`Type: ${stat.jobType}, workers: ${stat.workers}`);\n   *   }\n   * }\n   * ```\n   * @operationId getJobTypeStatistics\n   * @tags Job\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getJobTypeStatistics(input: getJobTypeStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getJobTypeStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getJobTypeStatistics>>;\n  getJobTypeStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getJobTypeStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getJobTypeStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get job statistics by worker\n   *\n   * Get statistics about jobs, grouped by worker, for a given job type.\n   *\n    *\n   * @example Get job worker statistics\n   * ```ts\n   * async function getJobWorkerStatisticsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getJobWorkerStatistics(\n   *     {\n   *       filter: {\n   *         from: '2025-01-01T00:00:00Z',\n   *         to: '2025-12-31T23:59:59Z',\n   *         jobType: 'payment-processing',\n   *       },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(`Worker: ${stat.worker}, completed: ${stat.completed.count}`);\n   *   }\n   * }\n   * ```\n   * @operationId getJobWorkerStatistics\n   * @tags Job\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getJobWorkerStatistics(input: getJobWorkerStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getJobWorkerStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getJobWorkerStatistics>>;\n  getJobWorkerStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getJobWorkerStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getJobWorkerStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get license status\n   *\n   * Obtains the status of the current Camunda license.\n    *\n   * @example Get license information\n   * ```ts\n   * async function getLicenseExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const license = await camunda.getLicense();\n   * \n   *   console.log(`License type: ${license.validLicense}`);\n   * }\n   * ```\n   * @operationId getLicense\n   * @tags License\n   */\n  getLicense(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getLicense>>;\n  getLicense(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getLicense(this, options);\n  }\n\n  /**\n   * Get a mapping rule\n   *\n   * Gets the mapping rule with the given ID.\n   *\n    *\n   * @example Get a mapping rule\n   * ```ts\n   * async function getMappingRuleExample(mappingRuleId: MappingRuleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const rule = await camunda.getMappingRule(\n   *     { mappingRuleId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Rule: ${rule.name} (${rule.claimName}=${rule.claimValue})`);\n   * }\n   * ```\n   * @operationId getMappingRule\n   * @tags Mapping rule\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getMappingRule(input: getMappingRuleInput, /** Management of eventual consistency **/ consistencyManagement: getMappingRuleConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getMappingRule>>;\n  getMappingRule(arg: any, /** Management of eventual consistency **/ consistencyManagement: getMappingRuleConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getMappingRule(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get process definition\n   *\n   * Returns process definition as JSON.\n    *\n   * @example Get a process definition\n   * ```ts\n   * async function getProcessDefinitionExample(processDefinitionKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const definition = await camunda.getProcessDefinition(\n   *     { processDefinitionKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Process: ${definition.processDefinitionId} v${definition.version}`);\n   * }\n   * ```\n   * @operationId getProcessDefinition\n   * @tags Process definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessDefinition(input: getProcessDefinitionInput, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessDefinition>>;\n  getProcessDefinition(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessDefinition(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get process instance statistics\n   *\n   * Get statistics about process instances, grouped by process definition and tenant.\n   *\n    *\n   * @example Get process definition instance statistics\n   * ```ts\n   * async function getProcessDefinitionInstanceStatisticsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessDefinitionInstanceStatistics(\n   *     {},\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(\n   *       `Definition ${stat.processDefinitionId}: ${stat.activeInstancesWithoutIncidentCount} active`\n   *     );\n   *   }\n   * }\n   * ```\n   * @operationId getProcessDefinitionInstanceStatistics\n   * @tags Process definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessDefinitionInstanceStatistics(input: getProcessDefinitionInstanceStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionInstanceStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessDefinitionInstanceStatistics>>;\n  getProcessDefinitionInstanceStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionInstanceStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessDefinitionInstanceStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get process instance statistics by version\n   *\n   * Get statistics about process instances, grouped by version for a given process definition.\n   * The process definition ID must be provided as a required field in the request body filter.\n   *\n    *\n   * @example Get version statistics\n   * ```ts\n   * async function getProcessDefinitionInstanceVersionStatisticsExample(\n   *   processDefinitionId: ProcessDefinitionId\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessDefinitionInstanceVersionStatistics(\n   *     {\n   *       filter: {\n   *         processDefinitionId,\n   *       },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(\n   *       `Version ${stat.processDefinitionVersion}: ${stat.activeInstancesWithoutIncidentCount} active`\n   *     );\n   *   }\n   * }\n   * ```\n   * @operationId getProcessDefinitionInstanceVersionStatistics\n   * @tags Process definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessDefinitionInstanceVersionStatistics(input: getProcessDefinitionInstanceVersionStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionInstanceVersionStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessDefinitionInstanceVersionStatistics>>;\n  getProcessDefinitionInstanceVersionStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionInstanceVersionStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessDefinitionInstanceVersionStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get message subscription statistics\n   *\n   * Get message subscription statistics, grouped by process definition.\n   *\n    *\n   * @example Get message subscription statistics\n   * ```ts\n   * async function getProcessDefinitionMessageSubscriptionStatisticsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessDefinitionMessageSubscriptionStatistics(\n   *     {},\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(\n   *       `Definition ${stat.processDefinitionId}: ${stat.activeSubscriptions} subscriptions`\n   *     );\n   *   }\n   * }\n   * ```\n   * @operationId getProcessDefinitionMessageSubscriptionStatistics\n   * @tags Process definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessDefinitionMessageSubscriptionStatistics(input: getProcessDefinitionMessageSubscriptionStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionMessageSubscriptionStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessDefinitionMessageSubscriptionStatistics>>;\n  getProcessDefinitionMessageSubscriptionStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionMessageSubscriptionStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessDefinitionMessageSubscriptionStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get process definition statistics\n   *\n   * Get statistics about elements in currently running process instances by process definition key and search filter.\n    *\n   * @example Get process definition element statistics\n   * ```ts\n   * async function getProcessDefinitionStatisticsExample(processDefinitionKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessDefinitionStatistics(\n   *     { processDefinitionKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(`Element ${stat.elementId}: active=${stat.active}`);\n   *   }\n   * }\n   * ```\n   * @operationId getProcessDefinitionStatistics\n   * @tags Process definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessDefinitionStatistics(input: getProcessDefinitionStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessDefinitionStatistics>>;\n  getProcessDefinitionStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessDefinitionStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get process definition XML\n   *\n   * Returns process definition as XML.\n    *\n   * @example Get process definition XML\n   * ```ts\n   * async function getProcessDefinitionXmlExample(processDefinitionKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const xml = await camunda.getProcessDefinitionXml(\n   *     { processDefinitionKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`XML length: ${JSON.stringify(xml).length}`);\n   * }\n   * ```\n   * @operationId getProcessDefinitionXML\n   * @tags Process definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessDefinitionXml(input: getProcessDefinitionXmlInput, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionXmlConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessDefinitionXml>>;\n  getProcessDefinitionXml(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessDefinitionXmlConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessDefinitionXml(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get process instance\n   *\n   * Get the process instance by the process instance key.\n    *\n   * @example Get a process instance\n   * ```ts\n   * async function getProcessInstanceExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const instance = await camunda.getProcessInstance(\n   *     { processInstanceKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`State: ${instance.state}`);\n   *   console.log(`Process: ${instance.processDefinitionId}`);\n   * }\n   * ```\n   * @operationId getProcessInstance\n   * @tags Process instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessInstance(input: getProcessInstanceInput, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessInstance>>;\n  getProcessInstance(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessInstance(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get call hierarchy\n   *\n   * Returns the call hierarchy for a given process instance, showing its ancestry up to the root instance.\n    *\n   * @example Get process instance call hierarchy\n   * ```ts\n   * async function getProcessInstanceCallHierarchyExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessInstanceCallHierarchy(\n   *     { processInstanceKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Call hierarchy entries: ${result.length}`);\n   * }\n   * ```\n   * @operationId getProcessInstanceCallHierarchy\n   * @tags Process instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessInstanceCallHierarchy(input: getProcessInstanceCallHierarchyInput, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceCallHierarchyConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessInstanceCallHierarchy>>;\n  getProcessInstanceCallHierarchy(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceCallHierarchyConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessInstanceCallHierarchy(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get sequence flows\n   *\n   * Get sequence flows taken by the process instance.\n    *\n   * @example Get process instance sequence flows\n   * ```ts\n   * async function getProcessInstanceSequenceFlowsExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessInstanceSequenceFlows(\n   *     { processInstanceKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const flow of result.items ?? []) {\n   *     console.log(`Sequence flow: ${flow.sequenceFlowId}`);\n   *   }\n   * }\n   * ```\n   * @operationId getProcessInstanceSequenceFlows\n   * @tags Process instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessInstanceSequenceFlows(input: getProcessInstanceSequenceFlowsInput, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceSequenceFlowsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessInstanceSequenceFlows>>;\n  getProcessInstanceSequenceFlows(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceSequenceFlowsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessInstanceSequenceFlows(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get element instance statistics\n   *\n   * Get statistics about elements by the process instance key.\n    *\n   * @example Get process instance statistics\n   * ```ts\n   * async function getProcessInstanceStatisticsExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessInstanceStatistics(\n   *     { processInstanceKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(`Element ${stat.elementId}: active=${stat.active}`);\n   *   }\n   * }\n   * ```\n   * @operationId getProcessInstanceStatistics\n   * @tags Process instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessInstanceStatistics(input: getProcessInstanceStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessInstanceStatistics>>;\n  getProcessInstanceStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessInstanceStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get process instance statistics by definition\n   *\n   * Returns statistics for active process instances with incidents, grouped by process\n   * definition. The result set is scoped to a specific incident error hash code, which must be\n   * provided as a filter in the request body.\n   *\n    *\n   * @example Get instance statistics by definition\n   * ```ts\n   * async function getProcessInstanceStatisticsByDefinitionExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessInstanceStatisticsByDefinition(\n   *     {\n   *       filter: {\n   *         errorHashCode: 12345,\n   *       },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(\n   *       `Definition ${stat.processDefinitionId}: ${stat.activeInstancesWithErrorCount} incidents`\n   *     );\n   *   }\n   * }\n   * ```\n   * @operationId getProcessInstanceStatisticsByDefinition\n   * @tags Incident\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessInstanceStatisticsByDefinition(input: getProcessInstanceStatisticsByDefinitionInput, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceStatisticsByDefinitionConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessInstanceStatisticsByDefinition>>;\n  getProcessInstanceStatisticsByDefinition(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceStatisticsByDefinitionConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessInstanceStatisticsByDefinition(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get process instance statistics by error\n   *\n   * Returns statistics for active process instances that currently have active incidents,\n   * grouped by incident error hash code.\n   *\n    *\n   * @example Get instance statistics by error\n   * ```ts\n   * async function getProcessInstanceStatisticsByErrorExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessInstanceStatisticsByError(\n   *     {},\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(`Error: ${stat.errorMessage}, count: ${stat.activeInstancesWithErrorCount}`);\n   *   }\n   * }\n   * ```\n   * @operationId getProcessInstanceStatisticsByError\n   * @tags Incident\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessInstanceStatisticsByError(input: getProcessInstanceStatisticsByErrorInput, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceStatisticsByErrorConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessInstanceStatisticsByError>>;\n  getProcessInstanceStatisticsByError(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceStatisticsByErrorConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessInstanceStatisticsByError(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get wait state statistics\n   *\n   * Get statistics about waiting element instances by the process instance key, grouped by element id.\n    *\n   * @example Get process instance wait state statistics\n   * ```ts\n   * async function getProcessInstanceWaitStateStatisticsExample(\n   *   processInstanceKey: ProcessInstanceKey\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.getProcessInstanceWaitStateStatistics(\n   *     { processInstanceKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const stat of result.items ?? []) {\n   *     console.log(`Element ${stat.elementId}: waiting=${stat.waitingCount}`);\n   *   }\n   * }\n   * ```\n   * @operationId getProcessInstanceWaitStateStatistics\n   * @tags Process instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getProcessInstanceWaitStateStatistics(input: getProcessInstanceWaitStateStatisticsInput, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceWaitStateStatisticsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getProcessInstanceWaitStateStatistics>>;\n  getProcessInstanceWaitStateStatistics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getProcessInstanceWaitStateStatisticsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getProcessInstanceWaitStateStatistics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get resource\n   *\n   * Returns a deployed resource.\n   * :::info\n   * This endpoint does not return BPMN process definitions, DMN decision definitions, or form\n   * resources. To query BPMN process definitions or DMN decision definitions, use their\n   * respective APIs.\n   * :::\n   *\n    *\n   * @example Get a resource\n   * ```ts\n   * async function getResourceExample(resourceKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const resource = await camunda.getResource(\n   *     {\n   *       resourceKey,\n   *     },\n   *     { consistency: { waitUpToMs: 0 } }\n   *   );\n   * \n   *   console.log(`Resource: ${resource.resourceName} (${resource.resourceId})`);\n   * }\n   * ```\n   * @operationId getResource\n   * @tags Resource\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getResource(input: getResourceInput, /** Management of eventual consistency **/ consistencyManagement: getResourceConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getResource>>;\n  getResource(arg: any, /** Management of eventual consistency **/ consistencyManagement: getResourceConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getResource(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get RPA resource content (deprecated)\n   *\n   * **Deprecated** — use `/resources/{resourceKey}/content/binary` instead, which supports all\n   * resource types and returns content as binary (octet-stream).\n   *\n   * Returns the content of a deployed RPA resource as JSON.\n   * :::info\n   * This endpoint only supports RPA resources. For generic resource content in binary format,\n   * use the `/resources/{resourceKey}/content/binary` endpoint.\n   * :::\n   *\n   *\n   * @deprecated\n    *\n   * @example Get resource content\n   * ```ts\n   * async function getResourceContentExample(resourceKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const content = await camunda.getResourceContent(\n   *     {\n   *       resourceKey,\n   *     },\n   *     { consistency: { waitUpToMs: 0 } }\n   *   );\n   * \n   *   console.log(`Content retrieved (type: ${typeof content})`);\n   * }\n   * ```\n   * @operationId getResourceContent\n   * @tags Resource\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getResourceContent(input: getResourceContentInput, /** Management of eventual consistency **/ consistencyManagement: getResourceContentConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getResourceContent>>;\n  getResourceContent(arg: any, /** Management of eventual consistency **/ consistencyManagement: getResourceContentConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getResourceContent(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get resource content as binary\n   *\n   * Returns the content of a deployed resource in binary format (octet-stream).\n   * :::info\n   * This endpoint does not return BPMN process definitions, DMN decision definitions, or form\n   * resources. To query BPMN process definitions or DMN decision definitions, use their\n   * respective APIs.\n   * :::\n   *\n    *\n   * @example Get resource content as binary\n   * ```ts\n   * async function getResourceContentBinaryExample(resourceKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const content = await camunda.getResourceContentBinary(\n   *     {\n   *       resourceKey,\n   *     },\n   *     { consistency: { waitUpToMs: 0 } }\n   *   );\n   * \n   *   console.log(`Binary content retrieved (type: ${typeof content})`);\n   * }\n   * ```\n   * @operationId getResourceContentBinary\n   * @tags Resource\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getResourceContentBinary(input: getResourceContentBinaryInput, /** Management of eventual consistency **/ consistencyManagement: getResourceContentBinaryConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getResourceContentBinary>>;\n  getResourceContentBinary(arg: any, /** Management of eventual consistency **/ consistencyManagement: getResourceContentBinaryConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getResourceContentBinary(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get the status of the restore that is currently in progress\n   *\n   * Returns the status of the restore that is currently in progress, reported per broker and per partition. There is at most one restore in flight at any time. Once the restore has finished this endpoint returns 404; the per-partition detail is not retained after completion.\n    *\n   * @example Get restore status\n   * ```ts\n   * async function getRestoreStatusExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const status = await camunda.getRestoreStatus();\n   * \n   *   console.log(`Restore status: ${status.status} (change ${status.changeId})`);\n   *   for (const broker of status.brokers) {\n   *     console.log(\n   *       `  Broker ${broker.brokerId}: ${broker.partitionsRestored}/${broker.partitionsToRestore} partitions restored`\n   *     );\n   *   }\n   * }\n   * ```\n   * @operationId getRestoreStatus\n   * @tags Recovery\n   */\n  getRestoreStatus(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getRestoreStatus>>;\n  getRestoreStatus(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getRestoreStatus(this, options);\n  }\n\n  /**\n   * Get role\n   *\n   * Get a role by its ID.\n    *\n   * @example Get a role\n   * ```ts\n   * async function getRoleExample(roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const role = await camunda.getRole({ roleId }, { consistency: { waitUpToMs: 5000 } });\n   * \n   *   console.log(`Role: ${role.name}`);\n   * }\n   * ```\n   * @operationId getRole\n   * @tags Role\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getRole(input: getRoleInput, /** Management of eventual consistency **/ consistencyManagement: getRoleConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getRole>>;\n  getRole(arg: any, /** Management of eventual consistency **/ consistencyManagement: getRoleConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getRole(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get runtime backup\n   *\n   * Returns detailed status of the runtime backup with the given id.\n    *\n   * @example Get a runtime backup\n   * ```ts\n   * async function getRuntimeBackupExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const backup = await camunda.getRuntimeBackup({ backupId: 100 });\n   * \n   *   console.log(`Backup ${backup.backupId}: ${backup.state}`);\n   *   for (const partition of backup.details) {\n   *     console.log(`  Partition ${partition.partitionId}: ${partition.state}`);\n   *   }\n   * }\n   * ```\n   * @operationId getRuntimeBackup\n   * @tags Backup\n   */\n  getRuntimeBackup(input: getRuntimeBackupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getRuntimeBackup>>;\n  getRuntimeBackup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getRuntimeBackup(this, arg, options);\n  }\n\n  /**\n   * Get a runtime backup across physical tenants\n   *\n   * Reports what every physical tenant of the cluster, or the one named by `physicalTenantId`, holds for the given backup id, plus the state aggregated over all of them. A tenant that was reached and does not hold this backup reports `DOES_NOT_EXIST`, which is a successful observation rather than a failure — so a backup only some tenants hold aggregates to `INCOMPLETE`, the same way a backup only some partitions hold does within one tenant.\n   *\n   * The request is all-or-nothing: a physical tenant whose state cannot be read fails the whole request. Narrow the request with `physicalTenantId` to read the tenants that can still be reached.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Use `GET /v2/backups/runtime/{backupId}` to act as a single physical tenant.\n    *\n   * @example Get a runtime backup (cluster admin)\n   * ```ts\n   * async function getRuntimeBackupAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Looking a backup id up directly lists every targeted physical tenant,\n   *   // including the ones reporting `DOES_NOT_EXIST` — a backup that only some\n   *   // tenants hold is a supported outcome.\n   *   const backup = await camunda.getRuntimeBackupAsClusterAdmin({ backupId: 100 });\n   * \n   *   console.log(`Cluster runtime backup ${backup.backupId}: ${backup.state}`);\n   *   for (const tenant of backup.physicalTenants) {\n   *     console.log(`  [${tenant.physicalTenantId}] ${tenant.state}`);\n   *   }\n   * }\n   * ```\n   * @operationId getRuntimeBackupAsClusterAdmin\n   * @tags Backup\n   */\n  getRuntimeBackupAsClusterAdmin(input: getRuntimeBackupAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getRuntimeBackupAsClusterAdmin>>;\n  getRuntimeBackupAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getRuntimeBackupAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Get runtime backup state\n   *\n   * Returns the current checkpoint and backup state of every partition of the physical\n   * tenant. Unlike the `backupRuntime` actuator, this fails the whole request if the\n   * checkpoint state or the backup ranges cannot be retrieved from any partition, instead\n   * of silently returning an empty section.\n   *\n    *\n   * @example Get the runtime backup state\n   * ```ts\n   * async function getRuntimeBackupStateExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const state = await camunda.getRuntimeBackupState();\n   * \n   *   for (const checkpoint of state.checkpointStates) {\n   *     console.log(\n   *       `Partition ${checkpoint.partitionId} checkpoint ${checkpoint.checkpointId} (${checkpoint.checkpointType})`\n   *     );\n   *   }\n   *   for (const range of state.ranges) {\n   *     console.log(\n   *       `Partition ${range.partitionId} range: ${range.start?.checkpointId} -> ${range.end?.checkpointId}`\n   *     );\n   *   }\n   * }\n   * ```\n   * @operationId getRuntimeBackupState\n   * @tags Backup\n   */\n  getRuntimeBackupState(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getRuntimeBackupState>>;\n  getRuntimeBackupState(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getRuntimeBackupState(this, options);\n  }\n\n  /**\n   * Get runtime backup state across physical tenants\n   *\n   * Reports the checkpoint and backup state of every partition of every physical tenant of the cluster, or of the one named by `physicalTenantId`, grouped by physical tenant. Checkpoint ids and log positions only mean anything within one physical tenant's partitions, so nothing is aggregated across tenants.\n   *\n   * The request is all-or-nothing: a physical tenant whose state cannot be read fails the whole request rather than contributing an empty section, which an operator making a delete or restore decision could not tell apart from \"nothing to report yet\". Narrow the request with `physicalTenantId` to read the tenants that can still be reached.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Use `GET /v2/backups/runtime/state` to act as a single physical tenant.\n    *\n   * @example Get the runtime backup state (cluster admin)\n   * ```ts\n   * async function getRuntimeBackupStateAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Returns the checkpoint and backup state of every targeted physical tenant.\n   *   // Nothing is aggregated across tenants — checkpoint ids and log positions only\n   *   // mean anything within one tenant's partitions.\n   *   const clusterState = await camunda.getRuntimeBackupStateAsClusterAdmin({});\n   * \n   *   for (const tenant of clusterState.physicalTenants) {\n   *     console.log(`[${tenant.physicalTenantId}] ${tenant.state.checkpointStates.length} checkpoints`);\n   *   }\n   * }\n   * ```\n   * @operationId getRuntimeBackupStateAsClusterAdmin\n   * @tags Backup\n   */\n  getRuntimeBackupStateAsClusterAdmin(input: getRuntimeBackupStateAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getRuntimeBackupStateAsClusterAdmin>>;\n  getRuntimeBackupStateAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getRuntimeBackupStateAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Get process start form\n   *\n   * Get the start form of a process.\n   * Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.\n   *\n    *\n   * @example Get start process form\n   * ```ts\n   * async function getStartProcessFormExample(processDefinitionKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const form = await camunda.getStartProcessForm(\n   *     { processDefinitionKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   if (form) {\n   *     console.log(`Form key: ${form.formKey}`);\n   *   }\n   * }\n   * ```\n   * @operationId getStartProcessForm\n   * @tags Process definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getStartProcessForm(input: getStartProcessFormInput, /** Management of eventual consistency **/ consistencyManagement: getStartProcessFormConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getStartProcessForm>>;\n  getStartProcessForm(arg: any, /** Management of eventual consistency **/ consistencyManagement: getStartProcessFormConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getStartProcessForm(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get physical tenant status\n   *\n   * Checks the health status of the default physical tenant by verifying if there's at least one partition of its group with a healthy leader. This endpoint is scoped to the default physical tenant only: it is available unprefixed and at `/physical-tenants/default/v2/status`, but not for any other physical tenant id (`/physical-tenants/{id}/v2/status` returns 404 for every other id, whether or not a physical tenant with that id exists). On a cluster with only the default physical tenant this endpoint answers the same question as `/cluster/v2/status`, though not with the same response: `/cluster/v2/status` reports its status in a body and so also distinguishes a degraded tenant from a healthy one. Use `/cluster/v2/status` for the aggregated status of the whole cluster, or `/physical-tenants/{id}/v2/topology` for the health of a specific physical tenant's partitions.\n    *\n   * @example Check cluster status\n   * ```ts\n   * async function getStatusExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.getStatus();\n   * \n   *   console.log('Cluster is healthy');\n   * }\n   * ```\n   * @operationId getStatus\n   * @tags Cluster\n   */\n  getStatus(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getStatus>>;\n  getStatus(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getStatus(this, options);\n  }\n\n  /**\n   * System configuration (alpha)\n   *\n   * Returns the current system configuration. The response is an envelope\n   * that groups settings by feature area.\n   *\n   * This endpoint is an alpha feature and may be subject to change\n   * in future releases.\n   *\n    *\n   * @example Get system configuration\n   * ```ts\n   * async function getSystemConfigurationExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const config = await camunda.getSystemConfiguration();\n   * \n   *   console.log(`Configuration loaded: ${JSON.stringify(config)}`);\n   * }\n   * ```\n   * @operationId getSystemConfiguration\n   * @tags System\n   */\n  getSystemConfiguration(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getSystemConfiguration>>;\n  getSystemConfiguration(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getSystemConfiguration(this, options);\n  }\n\n  /**\n   * Get tenant\n   *\n   * Retrieves a single tenant by tenant ID.\n    *\n   * @example Get a tenant\n   * ```ts\n   * async function getTenantExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const tenant = await camunda.getTenant({ tenantId }, { consistency: { waitUpToMs: 5000 } });\n   * \n   *   console.log(`Tenant: ${tenant.name}`);\n   * }\n   * ```\n   * @operationId getTenant\n   * @tags Tenant\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getTenant(input: getTenantInput, /** Management of eventual consistency **/ consistencyManagement: getTenantConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getTenant>>;\n  getTenant(arg: any, /** Management of eventual consistency **/ consistencyManagement: getTenantConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getTenant(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get a tenant-scoped cluster variable\n   *\n   * Get a tenant-scoped cluster variable.\n    *\n   * @example Get a tenant cluster variable\n   * ```ts\n   * async function getTenantClusterVariableExample(tenantId: TenantId, name: ClusterVariableName) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const variable = await camunda.getTenantClusterVariable(\n   *     {\n   *       tenantId,\n   *       name,\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`${variable.name} = ${variable.value}`);\n   * }\n   * ```\n   * @operationId getTenantClusterVariable\n   * @tags Cluster Variable\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getTenantClusterVariable(input: getTenantClusterVariableInput, /** Management of eventual consistency **/ consistencyManagement: getTenantClusterVariableConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getTenantClusterVariable>>;\n  getTenantClusterVariable(arg: any, /** Management of eventual consistency **/ consistencyManagement: getTenantClusterVariableConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getTenantClusterVariable(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get cluster topology\n   *\n   * Obtains the current topology of the cluster the gateway is part of.\n    *\n   * @example Get cluster topology\n   * ```ts\n   * async function getTopologyExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const topology = await camunda.getTopology();\n   * \n   *   console.log(`Cluster size: ${topology.clusterSize}`);\n   *   console.log(`Partitions: ${topology.partitionsCount}`);\n   *   for (const broker of topology.brokers ?? []) {\n   *     console.log(`  Broker ${broker.nodeId}: ${broker.host}:${broker.port}`);\n   *   }\n   * }\n   * ```\n   * @operationId getTopology\n   * @tags Cluster\n   */\n  getTopology(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getTopology>>;\n  getTopology(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getTopology(this, options);\n  }\n\n  /**\n   * Get usage metrics\n   *\n   * Retrieve the usage metrics based on given criteria.\n    *\n   * @example Get usage metrics\n   * ```ts\n   * async function getUsageMetricsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const metrics = await camunda.getUsageMetrics(\n   *     {\n   *       startTime: '2025-01-01T00:00:00Z',\n   *       endTime: '2025-12-31T23:59:59Z',\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`Usage metrics retrieved: ${JSON.stringify(metrics)}`);\n   * }\n   * ```\n   * @operationId getUsageMetrics\n   * @tags System\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getUsageMetrics(input: getUsageMetricsInput, /** Management of eventual consistency **/ consistencyManagement: getUsageMetricsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getUsageMetrics>>;\n  getUsageMetrics(arg: any, /** Management of eventual consistency **/ consistencyManagement: getUsageMetricsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getUsageMetrics(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get user\n   *\n   * Get a user by its username.\n    *\n   * @example Get a user\n   * ```ts\n   * async function getUserExample(username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const user = await camunda.getUser({ username }, { consistency: { waitUpToMs: 5000 } });\n   * \n   *   console.log(`User: ${user.name} (${user.email})`);\n   * }\n   * ```\n   * @operationId getUser\n   * @tags User\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getUser(input: getUserInput, /** Management of eventual consistency **/ consistencyManagement: getUserConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getUser>>;\n  getUser(arg: any, /** Management of eventual consistency **/ consistencyManagement: getUserConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getUser(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get user task\n   *\n   * Get the user task by the user task key.\n    *\n   * @example Get a user task\n   * ```ts\n   * async function getUserTaskExample(userTaskKey: UserTaskKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const task = await camunda.getUserTask({ userTaskKey }, { consistency: { waitUpToMs: 5000 } });\n   * \n   *   console.log(`Task: ${task.name} (${task.state})`);\n   * }\n   * ```\n   * @operationId getUserTask\n   * @tags User task\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getUserTask(input: getUserTaskInput, /** Management of eventual consistency **/ consistencyManagement: getUserTaskConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getUserTask>>;\n  getUserTask(arg: any, /** Management of eventual consistency **/ consistencyManagement: getUserTaskConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getUserTask(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get user task form\n   *\n   * Get the form of a user task.\n   * Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.\n   *\n    *\n   * @example Get a user task form\n   * ```ts\n   * async function getUserTaskFormExample(userTaskKey: UserTaskKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const form = await camunda.getUserTaskForm(\n   *     { userTaskKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   if (form) {\n   *     console.log(`Form key: ${form.formKey}`);\n   *   }\n   * }\n   * ```\n   * @operationId getUserTaskForm\n   * @tags User task\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getUserTaskForm(input: getUserTaskFormInput, /** Management of eventual consistency **/ consistencyManagement: getUserTaskFormConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getUserTaskForm>>;\n  getUserTaskForm(arg: any, /** Management of eventual consistency **/ consistencyManagement: getUserTaskFormConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getUserTaskForm(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Get variable\n   *\n   * Get a variable by its key.\n   *\n   * This endpoint returns both process-level and local (element-scoped) variables.\n   * The variable's scopeKey indicates whether it's a process-level variable or scoped to a\n   * specific element instance.\n    *\n   * @example Get a variable\n   * ```ts\n   * async function getVariableExample(variableKey: VariableKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const variable = await camunda.getVariable(\n   *     { variableKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   console.log(`${variable.name} = ${variable.value}`);\n   * }\n   * ```\n   * @operationId getVariable\n   * @tags Variable\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  getVariable(input: getVariableInput, /** Management of eventual consistency **/ consistencyManagement: getVariableConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.getVariable>>;\n  getVariable(arg: any, /** Management of eventual consistency **/ consistencyManagement: getVariableConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.getVariable(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * List history backups\n   *\n   * Returns a list of all available history backups of the physical tenant, with their state\n   * and additional info, most recent first by snapshot start time.\n   *\n   * Only available on clusters whose secondary storage is Elasticsearch or OpenSearch.\n   *\n    *\n   * @example List history backups\n   * ```ts\n   * async function listHistoryBackupsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // `prefix` must end in a single '*'. Omit it to list every history backup.\n   *   const backups = await camunda.listHistoryBackups({ prefix: '10*' });\n   * \n   *   for (const backup of backups) {\n   *     console.log(`History backup ${backup.backupId}: ${backup.state}`);\n   *   }\n   * }\n   * ```\n   * @operationId listHistoryBackups\n   * @tags Backup\n   */\n  listHistoryBackups(input: listHistoryBackupsInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.listHistoryBackups>>;\n  listHistoryBackups(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.listHistoryBackups(this, arg, options);\n  }\n\n  /**\n   * List history backups across physical tenants\n   *\n   * Lists the history backups of every physical tenant of the cluster, or of the one named by `physicalTenantId`, grouped by backup id. A backup id that only some physical tenants hold is a supported outcome rather than a degraded one, so only the tenants that hold it are listed under it.\n   *\n   * The request is all-or-nothing: a physical tenant whose backups cannot be read fails the whole request rather than silently dropping out of the listing. Narrow the request with `physicalTenantId` to list the backups of the tenants that can still be read.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Only available on clusters whose secondary storage is Elasticsearch or OpenSearch. Use `GET /v2/backups/history` to act as a single physical tenant.\n    *\n   * @example List history backups (cluster admin)\n   * ```ts\n   * async function listHistoryBackupsAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // `prefix` must end in a single '*'. Omit `physicalTenantId` to span every\n   *   // physical tenant of the cluster — results are grouped by backup id, and each\n   *   // group lists only the tenants that hold that id.\n   *   const backups = await camunda.listHistoryBackupsAsClusterAdmin({ prefix: '10*' });\n   * \n   *   for (const backup of backups) {\n   *     console.log(`Cluster history backup ${backup.backupId}:`);\n   *     for (const tenant of backup.physicalTenants) {\n   *       console.log(`  [${tenant.physicalTenantId}] ${tenant.state}`);\n   *     }\n   *   }\n   * }\n   * ```\n   * @operationId listHistoryBackupsAsClusterAdmin\n   * @tags Backup\n   */\n  listHistoryBackupsAsClusterAdmin(input: listHistoryBackupsAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.listHistoryBackupsAsClusterAdmin>>;\n  listHistoryBackupsAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.listHistoryBackupsAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * List runtime backups\n   *\n   * Returns a list of all available runtime backups of the physical tenant, with their\n   * state and additional info, sorted in descending order of backupId.\n   *\n    *\n   * @example List runtime backups\n   * ```ts\n   * async function listRuntimeBackupsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // `prefix` must end in a single '*'. Omit it to list every backup.\n   *   const backups = await camunda.listRuntimeBackups({ prefix: '10*' });\n   * \n   *   for (const backup of backups) {\n   *     console.log(`Backup ${backup.backupId}: ${backup.state}`);\n   *   }\n   * }\n   * ```\n   * @operationId listRuntimeBackups\n   * @tags Backup\n   */\n  listRuntimeBackups(input: listRuntimeBackupsInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.listRuntimeBackups>>;\n  listRuntimeBackups(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.listRuntimeBackups(this, arg, options);\n  }\n\n  /**\n   * List runtime backups across physical tenants\n   *\n   * Lists the runtime backups of every physical tenant of the cluster, or of the one named by `physicalTenantId`, grouped by backup id. Every group reports every targeted tenant, including the ones holding nothing for that id, so a backup only some tenants hold aggregates to `INCOMPLETE` here exactly as it does when looked up directly — the state of a listed group can be trusted to say whether the cluster can be restored from it. A backup id that only some physical tenants hold is a supported outcome rather than a degraded one; tenants that generate their own backup ids never share one, so in that mode each backup forms its own group and the other tenants report `DOES_NOT_EXIST` under it.\n   *\n   * The request is all-or-nothing: a physical tenant whose backups cannot be read fails the whole request rather than silently dropping out of the listing. Narrow the request with `physicalTenantId` to list the backups of the tenants that can still be read.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Use `GET /v2/backups/runtime` to act as a single physical tenant.\n    *\n   * @example List runtime backups (cluster admin)\n   * ```ts\n   * async function listRuntimeBackupsAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // `prefix` must end in a single '*'. Omit `physicalTenantId` to span every\n   *   // physical tenant — results are grouped by backup id, and each group reports\n   *   // every targeted tenant, including ones holding nothing for that id (reported\n   *   // as `DOES_NOT_EXIST`).\n   *   const backups = await camunda.listRuntimeBackupsAsClusterAdmin({ prefix: '10*' });\n   * \n   *   for (const backup of backups) {\n   *     console.log(`Cluster runtime backup ${backup.backupId}: ${backup.state}`);\n   *     for (const tenant of backup.physicalTenants) {\n   *       console.log(`  [${tenant.physicalTenantId}] ${tenant.state}`);\n   *     }\n   *   }\n   * }\n   * ```\n   * @operationId listRuntimeBackupsAsClusterAdmin\n   * @tags Backup\n   */\n  listRuntimeBackupsAsClusterAdmin(input: listRuntimeBackupsAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.listRuntimeBackupsAsClusterAdmin>>;\n  listRuntimeBackupsAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.listRuntimeBackupsAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * List secrets\n   *\n   * List the `camunda.secrets.*` references known for the caller's physical tenant.\n   *\n   * Only references the caller holds `SECRET:READ` on are returned. This endpoint never\n   * returns secret values, only the reference names.\n   *\n   * The references are read from the secret stores configured for the caller's physical tenant.\n   * A store may hold names outside the reference name charset (for example one containing a\n   * dot); those are omitted, since `/secrets/resolve` would reject them and no permission can\n   * be granted on them.\n   *\n   * A returned reference is usable verbatim with `/secrets/resolve`. In a FEEL expression,\n   * however, a name that is not a bare identifier has to be backtick-escaped, since FEEL reads\n   * a bare dash as the minus operator: a listed `camunda.secrets.db-password` is written\n   * `` =camunda.secrets.`db-password` `` in a BPMN input mapping.\n   *\n    *\n   * @example List secret references\n   * ```ts\n   * async function listSecretsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // The request body is reserved for future filtering options and currently\n   *   // takes no properties.\n   *   const result = await camunda.listSecrets({});\n   * \n   *   // Only the references are returned — never the secret values. Use\n   *   // `resolveSecrets` to fetch a value when one is actually needed.\n   *   for (const reference of result.references) {\n   *     console.log(`Secret available: ${reference}`);\n   *   }\n   * }\n   * ```\n   * @operationId listSecrets\n   * @tags Secret\n   */\n  listSecrets(input: listSecretsInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.listSecrets>>;\n  listSecrets(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.listSecrets(this, arg, options);\n  }\n\n  /**\n   * Migrate process instance\n   *\n   * Migrates a process instance to a new process definition.\n   * This request can contain multiple mapping instructions to define mapping between the active\n   * process instance's elements and target process definition elements.\n   *\n   * Use this to upgrade a process instance to a new version of a process or to\n   * a different process definition, e.g. to keep your running instances up-to-date with the\n   * latest process improvements.\n   *\n    *\n   * @example Migrate a process instance\n   * ```ts\n   * async function migrateProcessInstanceExample(\n   *   processInstanceKey: ProcessInstanceKey,\n   *   targetProcessDefinitionKey: ProcessDefinitionKey,\n   *   sourceElementId: ElementId,\n   *   targetElementId: ElementId\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.migrateProcessInstance({\n   *     processInstanceKey,\n   *     targetProcessDefinitionKey,\n   *     mappingInstructions: [\n   *       {\n   *         sourceElementId,\n   *         targetElementId,\n   *       },\n   *     ],\n   *   });\n   * }\n   * ```\n   * @operationId migrateProcessInstance\n   * @tags Process instance\n   */\n  migrateProcessInstance(input: migrateProcessInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.migrateProcessInstance>>;\n  migrateProcessInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.migrateProcessInstance(this, arg, options);\n  }\n\n  /**\n   * Migrate process instances (batch)\n   *\n   * Migrate multiple process instances.\n   * Since only process instances with ACTIVE state can be migrated, any given\n   * filters for state are ignored and overridden during this batch operation.\n   * This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Migrate process instances in batch\n   * ```ts\n   * async function migrateProcessInstancesBatchOperationExample(\n   *   processDefinitionKey: ProcessDefinitionKey,\n   *   targetProcessDefinitionKey: ProcessDefinitionKey,\n   *   sourceElementId: ElementId,\n   *   targetElementId: ElementId\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.migrateProcessInstancesBatchOperation({\n   *     filter: {\n   *       processDefinitionKey,\n   *     },\n   *     migrationPlan: {\n   *       targetProcessDefinitionKey,\n   *       mappingInstructions: [\n   *         {\n   *           sourceElementId,\n   *           targetElementId,\n   *         },\n   *       ],\n   *     },\n   *   });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId migrateProcessInstancesBatchOperation\n   * @tags Process instance\n   */\n  migrateProcessInstancesBatchOperation(input: migrateProcessInstancesBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.migrateProcessInstancesBatchOperation>>;\n  migrateProcessInstancesBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.migrateProcessInstancesBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Modify process instance\n   *\n   * Modifies a running process instance.\n   * This request can contain multiple instructions to activate an element of the process or\n   * to terminate an active instance of an element.\n   *\n   * Use this to repair a process instance that is stuck on an element or took an unintended path.\n   * For example, because an external system is not available or doesn't respond as expected.\n   *\n    *\n   * @example Modify a process instance\n   * ```ts\n   * async function modifyProcessInstanceExample(\n   *   processInstanceKey: ProcessInstanceKey,\n   *   elementId: ElementId,\n   *   elementInstanceKey: ElementInstanceKey\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.modifyProcessInstance({\n   *     processInstanceKey,\n   *     activateInstructions: [{ elementId }],\n   *     terminateInstructions: [{ elementInstanceKey }],\n   *   });\n   * }\n   * ```\n   * @operationId modifyProcessInstance\n   * @tags Process instance\n   */\n  modifyProcessInstance(input: modifyProcessInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.modifyProcessInstance>>;\n  modifyProcessInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.modifyProcessInstance(this, arg, options);\n  }\n\n  /**\n   * Modify process instances (batch)\n   *\n   * Modify multiple process instances.\n   * Since only process instances with ACTIVE state can be modified, any given\n   * filters for state are ignored and overridden during this batch operation.\n   * In contrast to single modification operation, it is not possible to add variable instructions or modify by element key.\n   * It is only possible to use the element id of the source and target.\n   * This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Modify process instances in batch\n   * ```ts\n   * async function modifyProcessInstancesBatchOperationExample(\n   *   processDefinitionKey: ProcessDefinitionKey,\n   *   sourceElementId: ElementId,\n   *   targetElementId: ElementId\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.modifyProcessInstancesBatchOperation({\n   *     filter: {\n   *       processDefinitionKey,\n   *     },\n   *     moveInstructions: [\n   *       {\n   *         sourceElementId,\n   *         targetElementId,\n   *       },\n   *     ],\n   *   });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId modifyProcessInstancesBatchOperation\n   * @tags Process instance\n   */\n  modifyProcessInstancesBatchOperation(input: modifyProcessInstancesBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.modifyProcessInstancesBatchOperation>>;\n  modifyProcessInstancesBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.modifyProcessInstancesBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Pause exporting across the whole cluster\n   *\n   * Pauses exporting on every physical tenant of the cluster in one call. With `soft=true`, every physical tenant is soft-paused instead.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here.\n    *\n   * @example Pause cluster exporting\n   * ```ts\n   * async function pauseClusterExportingExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Cluster-admin variant: pauses exporting on every physical tenant of the\n   *   // cluster. With `soft: true` exporting keeps running but its position is not\n   *   // committed, so the log is still not compacted.\n   *   await camunda.pauseClusterExporting({ soft: true });\n   * }\n   * ```\n   * @operationId pauseClusterExporting\n   * @tags Exporting\n   */\n  pauseClusterExporting(input: pauseClusterExportingInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.pauseClusterExporting>>;\n  pauseClusterExporting(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.pauseClusterExporting(this, arg, options);\n  }\n\n  /**\n   * Pause exporting\n   *\n   * Pauses exporting on all partitions of the physical tenant. While paused, exported records\n   * are not committed, so the log is not compacted for the affected partitions.\n   *\n   * With `soft=true`, exporting continues to run but its position is not committed, so the\n   * state after resuming is identical to a hard pause; use this variant when exporting must\n   * keep progressing (e.g. to avoid falling behind) while still preventing log compaction,\n   * such as during a backup.\n   *\n    *\n   * @example Pause exporting\n   * ```ts\n   * async function pauseExportingExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // With `soft: true` exporting keeps running but its position is not committed,\n   *   // so the log is still not compacted — use it when exporting must keep\n   *   // progressing, for example while a backup is taken.\n   *   await camunda.pauseExporting({ soft: true });\n   * }\n   * ```\n   * @operationId pauseExporting\n   * @tags Exporting\n   */\n  pauseExporting(input: pauseExportingInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.pauseExporting>>;\n  pauseExporting(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.pauseExporting(this, arg, options);\n  }\n\n  /**\n   * Pin internal clock (alpha)\n   *\n   * Set a precise, static time for the Zeebe engine's internal clock.\n   * When the clock is pinned, it remains at the specified time and does not advance.\n   * To change the time, the clock must be pinned again with a new timestamp.\n   *\n   * This endpoint is an alpha feature and may be subject to change\n   * in future releases.\n   *\n    *\n   * @example Pin the cluster clock\n   * ```ts\n   * async function pinClockExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.pinClock({\n   *     timestamp: 1735689599000,\n   *   });\n   * \n   *   console.log('Clock pinned');\n   * }\n   * ```\n   * @operationId pinClock\n   * @tags Clock\n   */\n  pinClock(input: pinClockInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.pinClock>>;\n  pinClock(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.pinClock(this, arg, options);\n  }\n\n  /**\n   * Publish message\n   *\n   * Publishes a single message.\n   * Messages are published to specific partitions computed from their correlation keys.\n   * Messages can be buffered.\n   * The endpoint does not wait for a correlation result.\n   * Use the message correlation endpoint for such use cases.\n   *\n    *\n   * @example Publish a message\n   * ```ts\n   * async function publishMessageExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.publishMessage({\n   *     name: 'order-payment-received',\n   *     correlationKey: 'ORD-12345',\n   *     timeToLive: 60000,\n   *     variables: {\n   *       paymentId: 'PAY-123',\n   *     },\n   *   });\n   * }\n   * ```\n   * @operationId publishMessage\n   * @tags Message\n   */\n  publishMessage(input: publishMessageInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.publishMessage>>;\n  publishMessage(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.publishMessage(this, arg, options);\n  }\n\n  /**\n   * Reset internal clock (alpha)\n   *\n   * Resets the Zeebe engine's internal clock to the current system time, enabling it to tick in real-time.\n   * This operation is useful for returning the clock to\n   * normal behavior after it has been pinned to a specific time.\n   *\n   * This endpoint is an alpha feature and may be subject to change\n   * in future releases.\n   *\n    *\n   * @example Reset the cluster clock\n   * ```ts\n   * async function resetClockExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.resetClock();\n   * \n   *   console.log('Clock reset');\n   * }\n   * ```\n   * @operationId resetClock\n   * @tags Clock\n   */\n  resetClock(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resetClock>>;\n  resetClock(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resetClock(this, options);\n  }\n\n  /**\n   * Resolve incident\n   *\n   * Marks the incident as resolved; most likely a call to Update job will be necessary\n   * to reset the job's retries, followed by this call.\n   *\n    *\n   * @example Resolve an incident\n   * ```ts\n   * async function resolveIncidentExample(incidentKey: IncidentKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.resolveIncident({ incidentKey });\n   * }\n   * ```\n   * @operationId resolveIncident\n   * @tags Incident\n   */\n  resolveIncident(input: resolveIncidentInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resolveIncident>>;\n  resolveIncident(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resolveIncident(this, arg, options);\n  }\n\n  /**\n   * Resolve related incidents (batch)\n   *\n   * Resolves multiple instances of process instances.\n   * Since only process instances with ACTIVE state can have unresolved incidents, any given\n   * filters for state are ignored and overridden during this batch operation.\n   * This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Resolve incidents in batch\n   * ```ts\n   * async function resolveIncidentsBatchOperationExample(processDefinitionKey: ProcessDefinitionKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.resolveIncidentsBatchOperation({\n   *     filter: {\n   *       processDefinitionKey,\n   *     },\n   *   });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId resolveIncidentsBatchOperation\n   * @tags Process instance\n   */\n  resolveIncidentsBatchOperation(input: resolveIncidentsBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resolveIncidentsBatchOperation>>;\n  resolveIncidentsBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resolveIncidentsBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Resolve related incidents\n   *\n   * Creates a batch operation to resolve multiple incidents of a process instance.\n    *\n   * @example Resolve process instance incidents\n   * ```ts\n   * async function resolveProcessInstanceIncidentsExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.resolveProcessInstanceIncidents({ processInstanceKey });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId resolveProcessInstanceIncidents\n   * @tags Process instance\n   */\n  resolveProcessInstanceIncidents(input: resolveProcessInstanceIncidentsInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resolveProcessInstanceIncidents>>;\n  resolveProcessInstanceIncidents(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resolveProcessInstanceIncidents(this, arg, options);\n  }\n\n  /**\n   * Resolve secrets\n   *\n   * Resolve a deduplicated batch of `camunda.secrets.*` references for the caller's\n   * physical tenant in a single round-trip.\n   *\n   * Each reference is authorized and resolved independently. For valid requests, the endpoint\n   * always responds with HTTP 200: successfully resolved references are returned in `resolved`,\n   * while references that could not be resolved (for example not found, malformed or over-long,\n   * or the caller lacks `SECRET:REVEAL` on that reference) are returned in `errors`. A failure of\n   * one reference never fails the others. Only structurally invalid requests are rejected with\n   * HTTP 400: a missing or non-array `references` field, more than 20 references, or a null entry.\n   *\n   * References are resolved against the secret stores configured for the caller's physical\n   * tenant, served from the gateway's secret cache when the value is already cached and read\n   * from the store otherwise.\n   *\n    *\n   * @example Resolve secrets\n   * ```ts\n   * async function resolveSecretsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.resolveSecrets({\n   *     references: ['camunda.secrets.myApiToken', 'camunda.secrets.dbPassword'],\n   *   });\n   * \n   *   // Successfully resolved references are returned in `resolved`; references that\n   *   // could not be resolved are returned in `errors`, each with a typed error code.\n   *   // Never log a resolved value — it holds secret material. Pass it straight to the\n   *   // consumer that needs it (HTTP client, DB driver, ...) instead.\n   *   for (const resolved of result.resolved) {\n   *     console.log(`Resolved ${resolved.reference} (value redacted)`);\n   *     useSecret(resolved.value);\n   *   }\n   * \n   *   for (const error of result.errors) {\n   *     console.log(`Failed to resolve ${error.reference}: ${error.code} - ${error.message}`);\n   *   }\n   * }\n   * \n   * // Hands the resolved secret to whatever needs it, without logging it.\n   * function useSecret(_value: string) {}\n   * ```\n   * @operationId resolveSecrets\n   * @tags Secret\n   */\n  resolveSecrets(input: resolveSecretsInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resolveSecrets>>;\n  resolveSecrets(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resolveSecrets(this, arg, options);\n  }\n\n  /**\n   * Restore from a backup\n   *\n   * Restores the cluster from a backup. The restore is described either by a single backup ID or by a time range (`from`/`to`) that selects the backups to restore. This endpoint is only accessible while the cluster is in recovery mode; requests are rejected otherwise. The request is validated and acknowledged, but the restore itself is performed asynchronously.\n    *\n   * @example Restore from a backup\n   * ```ts\n   * async function restoreExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // The cluster must be in recovery mode before a restore is accepted. Provide\n   *   // either a list of backup IDs (one per partition) or a time range (`from`/`to`)\n   *   // that selects the backups to restore, but not both.\n   *   const change = await camunda.restore({\n   *     backupIds: [100, 101],\n   *   });\n   * \n   *   console.log(`Cluster change ${change.changeId}:`);\n   *   for (const group of change.plannedChanges) {\n   *     console.log(`  ${group.physicalTenantId ?? 'cluster-wide'}:`);\n   *     for (const op of group.operations) {\n   *       const mode = 'mode' in op ? op.mode : undefined;\n   *       console.log(`    ${op.operation}${mode ? ` -> ${mode}` : ''}`);\n   *     }\n   *   }\n   * }\n   * ```\n   * @operationId restore\n   * @tags Recovery\n   */\n  restore(input: restoreInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.restore>>;\n  restore(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.restore(this, arg, options);\n  }\n\n  /**\n   * Restore one or every physical tenant from a backup\n   *\n   * Restores physical tenants from backups. The restore is described either by a list of backup IDs or by a time range (`from`/`to`) that selects the backups to restore. Restores are only accepted while the targeted physical tenants are in recovery mode; requests are rejected otherwise. The request is validated and acknowledged, but the restore itself is performed asynchronously.\n   *\n   * If the `physicalTenantId` parameter is provided, only that physical tenant is restored and `overrides` must be omitted.\n   *\n   * If it is not provided, every physical tenant of the cluster is restored: those named in `overrides` with their own backup selection, all others with the selection at the top level of the request body.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here.\n    *\n   * @example Restore from a backup as cluster admin\n   * ```ts\n   * async function restoreAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // The cluster-admin variant can target a specific physical tenant and supports\n   *   // per-tenant overrides. Omit `physicalTenantId` to restore every physical\n   *   // tenant. Provide either backup IDs (one per partition) or a time range\n   *   // (`from`/`to`), but not both.\n   *   const change = await camunda.restoreAsClusterAdmin({\n   *     backupIds: [200, 201],\n   *     physicalTenantId: 'default',\n   *     dryRun: true,\n   *   });\n   * \n   *   console.log(`Cluster change ${change.changeId}:`);\n   *   for (const group of change.plannedChanges) {\n   *     console.log(`  ${group.physicalTenantId ?? 'cluster-wide'}:`);\n   *     for (const op of group.operations) {\n   *       const mode = 'mode' in op ? op.mode : undefined;\n   *       console.log(`    ${op.operation}${mode ? ` -> ${mode}` : ''}`);\n   *     }\n   *   }\n   * }\n   * ```\n   * @operationId restoreAsClusterAdmin\n   * @tags Recovery\n   */\n  restoreAsClusterAdmin(input: restoreAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.restoreAsClusterAdmin>>;\n  restoreAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.restoreAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Resume Batch operation\n   *\n   * Resumes a suspended batch operation.\n   * This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Resume a batch operation\n   * ```ts\n   * async function resumeBatchOperationExample(batchOperationKey: BatchOperationKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.resumeBatchOperation({ batchOperationKey });\n   * }\n   * ```\n   * @operationId resumeBatchOperation\n   * @tags Batch operation\n   */\n  resumeBatchOperation(input: resumeBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resumeBatchOperation>>;\n  resumeBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resumeBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Resume exporting across the whole cluster\n   *\n   * Resumes exporting on every physical tenant of the cluster in one call, after a pause or soft pause.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here.\n    *\n   * @example Resume cluster exporting\n   * ```ts\n   * async function resumeClusterExportingExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.resumeClusterExporting();\n   * }\n   * ```\n   * @operationId resumeClusterExporting\n   * @tags Exporting\n   */\n  resumeClusterExporting(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resumeClusterExporting>>;\n  resumeClusterExporting(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resumeClusterExporting(this, options);\n  }\n\n  /**\n   * Resume exporting\n   *\n   * Resumes exporting on all partitions of the physical tenant after a pause or soft pause.\n   *\n    *\n   * @example Resume exporting\n   * ```ts\n   * async function resumeExportingExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.resumeExporting();\n   * }\n   * ```\n   * @operationId resumeExporting\n   * @tags Exporting\n   */\n  resumeExporting(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resumeExporting>>;\n  resumeExporting(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resumeExporting(this, options);\n  }\n\n  /**\n   * Resume process instance\n   *\n   * Resumes a suspended process instance, returning it to the ACTIVE state and continuing processing.\n   * Only process instances in the SUSPENDED state can be resumed.\n   * A child process instance can be resumed independently of its parent or root process\n   * instance; resumption does not cascade to or from related instances.\n   *\n    *\n   * @example Resume a process instance\n   * ```ts\n   * async function resumeProcessInstanceExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.resumeProcessInstance({ processInstanceKey });\n   * }\n   * ```\n   * @operationId resumeProcessInstance\n   * @tags Process instance\n   */\n  resumeProcessInstance(input: resumeProcessInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resumeProcessInstance>>;\n  resumeProcessInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resumeProcessInstance(this, arg, options);\n  }\n\n  /**\n   * Resume process instances (batch)\n   *\n   * Resumes multiple suspended process instances.\n   * Any given filter for state or parentProcessInstanceKey is ignored and overridden, as only\n   * SUSPENDED process instances can be resumed and resumption does not cascade between parent\n   * and child instances, so child instances are resumed independently of their parent or root\n   * instance.\n   * This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Resume process instances in batch\n   * ```ts\n   * async function resumeProcessInstancesBatchOperationExample(\n   *   processDefinitionKey: ProcessDefinitionKey\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.resumeProcessInstancesBatchOperation({\n   *     filter: {\n   *       processDefinitionKey,\n   *     },\n   *   });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId resumeProcessInstancesBatchOperation\n   * @tags Process instance\n   */\n  resumeProcessInstancesBatchOperation(input: resumeProcessInstancesBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.resumeProcessInstancesBatchOperation>>;\n  resumeProcessInstancesBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.resumeProcessInstancesBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Search agent definitions\n   *\n   * Search for agent definitions based on given criteria.\n    *\n   * @example Search agent definitions\n   * ```ts\n   * async function searchAgentDefinitionsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchAgentDefinitions(\n   *     {\n   *       filter: { agentType: { $eq: 'AI_AGENT_TASK' } },\n   *       sort: [{ field: 'name', order: 'ASC' }],\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const definition of result.items ?? []) {\n   *     console.log(`${definition.agentDefinitionKey}: ${definition.name} (${definition.agentType})`);\n   *   }\n   *   console.log(`Total: ${result.page.totalItems}`);\n   * }\n   * ```\n   * @operationId searchAgentDefinitions\n   * @tags Agent definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchAgentDefinitions(input: searchAgentDefinitionsInput, /** Management of eventual consistency **/ consistencyManagement: searchAgentDefinitionsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchAgentDefinitions>>;\n  searchAgentDefinitions(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchAgentDefinitionsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchAgentDefinitions(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search agent instance history\n   *\n   * Searches the conversation history of an agent instance. Committed items\n   * are returned by default.\n   *\n    *\n   * @example Search agent instance history\n   * ```ts\n   * async function searchAgentInstanceHistoryExample(agentInstanceKey: AgentInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchAgentInstanceHistory(\n   *     {\n   *       agentInstanceKey,\n   *       filter: { role: { $eq: 'ASSISTANT' } },\n   *       sort: [{ field: 'producedAt', order: 'ASC' }],\n   *       page: { limit: 20 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const item of result.items ?? []) {\n   *     console.log(`${item.historyItemKey} (${item.role})`);\n   *   }\n   *   console.log(`Total: ${result.page.totalItems}`);\n   * }\n   * ```\n   * @operationId searchAgentInstanceHistory\n   * @tags Agent instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchAgentInstanceHistory(input: searchAgentInstanceHistoryInput, /** Management of eventual consistency **/ consistencyManagement: searchAgentInstanceHistoryConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchAgentInstanceHistory>>;\n  searchAgentInstanceHistory(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchAgentInstanceHistoryConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchAgentInstanceHistory(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search agent instances\n   *\n   * Search for agent instances based on given criteria.\n    *\n   * @example Search agent instances\n   * ```ts\n   * async function searchAgentInstancesExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchAgentInstances(\n   *     {\n   *       filter: { status: { $eq: 'IDLE' } },\n   *       sort: [{ field: 'creationDate', order: 'DESC' }],\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const instance of result.items ?? []) {\n   *     console.log(`${instance.agentInstanceKey}: ${instance.status}`);\n   *   }\n   *   console.log(`Total: ${result.page.totalItems}`);\n   * }\n   * ```\n   * @operationId searchAgentInstances\n   * @tags Agent instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchAgentInstances(input: searchAgentInstancesInput, /** Management of eventual consistency **/ consistencyManagement: searchAgentInstancesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchAgentInstances>>;\n  searchAgentInstances(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchAgentInstancesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchAgentInstances(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search audit logs\n   *\n   * Search for audit logs based on given criteria.\n    *\n   * @example Search audit logs\n   * ```ts\n   * async function searchAuditLogsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchAuditLogs(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const log of result.items ?? []) {\n   *     console.log(`${log.auditLogKey}: ${log.operationType}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchAuditLogs\n   * @tags Audit Log\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchAuditLogs(input: searchAuditLogsInput, /** Management of eventual consistency **/ consistencyManagement: searchAuditLogsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchAuditLogs>>;\n  searchAuditLogs(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchAuditLogsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchAuditLogs(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search authorizations\n   *\n   * Search for authorizations based on given criteria.\n    *\n   * @example Search authorizations\n   * ```ts\n   * async function searchAuthorizationsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchAuthorizations(\n   *     {\n   *       filter: { ownerType: 'USER' },\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const auth of result.items ?? []) {\n   *     console.log(`${auth.authorizationKey}: ${auth.ownerId} - ${auth.resourceType}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchAuthorizations\n   * @tags Authorization\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchAuthorizations(input: searchAuthorizationsInput, /** Management of eventual consistency **/ consistencyManagement: searchAuthorizationsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchAuthorizations>>;\n  searchAuthorizations(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchAuthorizationsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchAuthorizations(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search batch operation items\n   *\n   * Search for batch operation items based on given criteria.\n    *\n   * @example Search batch operation items\n   * ```ts\n   * async function searchBatchOperationItemsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchBatchOperationItems(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const item of result.items ?? []) {\n   *     console.log(`Item: ${item.itemKey} (${item.state})`);\n   *   }\n   * }\n   * ```\n   * @operationId searchBatchOperationItems\n   * @tags Batch operation\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchBatchOperationItems(input: searchBatchOperationItemsInput, /** Management of eventual consistency **/ consistencyManagement: searchBatchOperationItemsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchBatchOperationItems>>;\n  searchBatchOperationItems(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchBatchOperationItemsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchBatchOperationItems(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search batch operations\n   *\n   * Search for batch operations based on given criteria.\n    *\n   * @example Search batch operations\n   * ```ts\n   * async function searchBatchOperationsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchBatchOperations(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const batch of result.items ?? []) {\n   *     console.log(`${batch.batchOperationKey}: ${batch.batchOperationType} (${batch.state})`);\n   *   }\n   * }\n   * ```\n   * @operationId searchBatchOperations\n   * @tags Batch operation\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchBatchOperations(input: searchBatchOperationsInput, /** Management of eventual consistency **/ consistencyManagement: searchBatchOperationsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchBatchOperations>>;\n  searchBatchOperations(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchBatchOperationsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchBatchOperations(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search group clients\n   *\n   * Search clients assigned to a group.\n    *\n   * @example Search clients in a group\n   * ```ts\n   * async function searchClientsForGroupExample(groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchClientsForGroup(\n   *     { groupId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const client of result.items ?? []) {\n   *     console.log(`Client: ${client.clientId}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchClientsForGroup\n   * @tags Group\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchClientsForGroup(input: searchClientsForGroupInput, /** Management of eventual consistency **/ consistencyManagement: searchClientsForGroupConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchClientsForGroup>>;\n  searchClientsForGroup(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchClientsForGroupConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchClientsForGroup(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search role clients\n   *\n   * Search clients with assigned role.\n    *\n   * @example Search clients for a role\n   * ```ts\n   * async function searchClientsForRoleExample(roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchClientsForRole(\n   *     { roleId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const client of result.items ?? []) {\n   *     console.log(`Client: ${client.clientId}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchClientsForRole\n   * @tags Role\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchClientsForRole(input: searchClientsForRoleInput, /** Management of eventual consistency **/ consistencyManagement: searchClientsForRoleConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchClientsForRole>>;\n  searchClientsForRole(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchClientsForRoleConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchClientsForRole(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search clients for tenant\n   *\n   * Retrieves a filtered and sorted list of clients for a specified tenant.\n    *\n   * @example Search clients for a tenant\n   * ```ts\n   * async function searchClientsForTenantExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchClientsForTenant(\n   *     { tenantId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const client of result.items ?? []) {\n   *     console.log(`Client: ${client.clientId}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchClientsForTenant\n   * @tags Tenant\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchClientsForTenant(input: searchClientsForTenantInput, /** Management of eventual consistency **/ consistencyManagement: searchClientsForTenantConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchClientsForTenant>>;\n  searchClientsForTenant(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchClientsForTenantConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchClientsForTenant(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search for cluster variables based on given criteria. By default, long variable values in the response are truncated.\n    *\n   * @example Search cluster variables\n   * ```ts\n   * async function searchClusterVariablesExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchClusterVariables(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const variable of result.items ?? []) {\n   *     console.log(`${variable.name} = ${variable.value}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchClusterVariables\n   * @tags Cluster Variable\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchClusterVariables(input: searchClusterVariablesInput, /** Management of eventual consistency **/ consistencyManagement: searchClusterVariablesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchClusterVariables>>;\n  searchClusterVariables(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchClusterVariablesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchClusterVariables(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search correlated message subscriptions\n   *\n   * Search correlated message subscriptions based on given criteria.\n    *\n   * @example Search correlated message subscriptions\n   * ```ts\n   * async function searchCorrelatedMessageSubscriptionsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchCorrelatedMessageSubscriptions(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const sub of result.items ?? []) {\n   *     console.log(`Correlated subscription: ${sub.messageName}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchCorrelatedMessageSubscriptions\n   * @tags Message subscription\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchCorrelatedMessageSubscriptions(input: searchCorrelatedMessageSubscriptionsInput, /** Management of eventual consistency **/ consistencyManagement: searchCorrelatedMessageSubscriptionsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchCorrelatedMessageSubscriptions>>;\n  searchCorrelatedMessageSubscriptions(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchCorrelatedMessageSubscriptionsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchCorrelatedMessageSubscriptions(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search decision definitions\n   *\n   * Search for decision definitions based on given criteria.\n    *\n   * @example Search decision definitions\n   * ```ts\n   * async function searchDecisionDefinitionsExample(decisionDefinitionId: DecisionDefinitionId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchDecisionDefinitions(\n   *     {\n   *       filter: { decisionDefinitionId },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const definition of result.items ?? []) {\n   *     console.log(`${definition.decisionDefinitionId} v${definition.version}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchDecisionDefinitions\n   * @tags Decision definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchDecisionDefinitions(input: searchDecisionDefinitionsInput, /** Management of eventual consistency **/ consistencyManagement: searchDecisionDefinitionsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchDecisionDefinitions>>;\n  searchDecisionDefinitions(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchDecisionDefinitionsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchDecisionDefinitions(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search decision instances\n   *\n   * Search for decision instances based on given criteria.\n    *\n   * @example Search decision instances\n   * ```ts\n   * async function searchDecisionInstancesExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchDecisionInstances(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const instance of result.items ?? []) {\n   *     console.log(`${instance.decisionEvaluationKey}: ${instance.decisionDefinitionId}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchDecisionInstances\n   * @tags Decision instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchDecisionInstances(input: searchDecisionInstancesInput, /** Management of eventual consistency **/ consistencyManagement: searchDecisionInstancesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchDecisionInstances>>;\n  searchDecisionInstances(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchDecisionInstancesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchDecisionInstances(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search decision requirements\n   *\n   * Search for decision requirements based on given criteria.\n    *\n   * @example Search decision requirements\n   * ```ts\n   * async function searchDecisionRequirementsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchDecisionRequirements(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const req of result.items ?? []) {\n   *     console.log(`${req.decisionRequirementsKey}: ${req.decisionRequirementsId}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchDecisionRequirements\n   * @tags Decision requirements\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchDecisionRequirements(input: searchDecisionRequirementsInput, /** Management of eventual consistency **/ consistencyManagement: searchDecisionRequirementsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchDecisionRequirements>>;\n  searchDecisionRequirements(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchDecisionRequirementsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchDecisionRequirements(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search for incidents of a specific element instance\n   *\n   * Search for incidents caused by the specified element instance, including incidents of any child instances created from this element instance.\n   *\n   * Although the `elementInstanceKey` is provided as a path parameter to indicate the root element instance,\n   * you may also include an `elementInstanceKey` within the filter object to narrow results to specific\n   * child element instances. This is useful, for example, if you want to isolate incidents associated with\n   * nested or subordinate elements within the given element instance while excluding incidents directly tied\n   * to the root element itself.\n   *\n    *\n   * @example Search element instance incidents\n   * ```ts\n   * async function searchElementInstanceIncidentsExample(elementInstanceKey: ElementInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchElementInstanceIncidents(\n   *     { elementInstanceKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const incident of result.items ?? []) {\n   *     console.log(`Incident: ${incident.errorType}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchElementInstanceIncidents\n   * @tags Element instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchElementInstanceIncidents(input: searchElementInstanceIncidentsInput, /** Management of eventual consistency **/ consistencyManagement: searchElementInstanceIncidentsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchElementInstanceIncidents>>;\n  searchElementInstanceIncidents(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchElementInstanceIncidentsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchElementInstanceIncidents(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search element instances\n   *\n   * Search for element instances based on given criteria.\n    *\n   * @example Search element instances\n   * ```ts\n   * async function searchElementInstancesExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchElementInstances(\n   *     {\n   *       filter: {\n   *         processInstanceKey,\n   *       },\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const element of result.items ?? []) {\n   *     console.log(`${element.elementId}: ${element.type} (${element.state})`);\n   *   }\n   * }\n   * ```\n   * @operationId searchElementInstances\n   * @tags Element instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchElementInstances(input: searchElementInstancesInput, /** Management of eventual consistency **/ consistencyManagement: searchElementInstancesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchElementInstances>>;\n  searchElementInstances(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchElementInstancesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchElementInstances(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search element instance wait states\n   *\n   * Returns the wait states for element instances matching the given filter.\n   *\n    *\n   * @example Search element instance wait states\n   * ```ts\n   * async function searchElementInstanceWaitStatesExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchElementInstanceWaitStates(\n   *     {\n   *       filter: {\n   *         processInstanceKey,\n   *       },\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const waitState of result.items ?? []) {\n   *     const { details } = waitState;\n   *     let description: string;\n   *     if (details.waitStateType === 'JOB') {\n   *       description = `waiting on job '${details.jobType}'`;\n   *     } else if (details.waitStateType === 'MESSAGE') {\n   *       description = `waiting for message '${details.messageName}'`;\n   *     } else {\n   *       description = `waiting (${details.waitStateType})`;\n   *     }\n   *     console.log(`${waitState.elementId}: ${description}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchElementInstanceWaitStates\n   * @tags Element instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchElementInstanceWaitStates(input: searchElementInstanceWaitStatesInput, /** Management of eventual consistency **/ consistencyManagement: searchElementInstanceWaitStatesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchElementInstanceWaitStates>>;\n  searchElementInstanceWaitStates(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchElementInstanceWaitStatesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchElementInstanceWaitStates(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search global user task listeners\n   *\n   * Search for global user task listeners based on given criteria.\n    *\n   * @example Search global task listeners\n   * ```ts\n   * async function searchGlobalTaskListenersExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchGlobalTaskListeners(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const listener of result.items ?? []) {\n   *     console.log(`${listener.id}: ${listener.type} (${listener.eventTypes})`);\n   *   }\n   * }\n   * ```\n   * @operationId searchGlobalTaskListeners\n   * @tags Global listener\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchGlobalTaskListeners(input: searchGlobalTaskListenersInput, /** Management of eventual consistency **/ consistencyManagement: searchGlobalTaskListenersConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchGlobalTaskListeners>>;\n  searchGlobalTaskListeners(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchGlobalTaskListenersConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchGlobalTaskListeners(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search groups for tenant\n   *\n   * Retrieves a filtered and sorted list of groups for a specified tenant.\n    *\n   * @example Search groups for a tenant\n   * ```ts\n   * async function searchGroupIdsForTenantExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchGroupIdsForTenant(\n   *     { tenantId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const group of result.items ?? []) {\n   *     console.log(`Group: ${group.groupId}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchGroupIdsForTenant\n   * @tags Tenant\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchGroupIdsForTenant(input: searchGroupIdsForTenantInput, /** Management of eventual consistency **/ consistencyManagement: searchGroupIdsForTenantConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchGroupIdsForTenant>>;\n  searchGroupIdsForTenant(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchGroupIdsForTenantConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchGroupIdsForTenant(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search groups\n   *\n   * Search for groups based on given criteria.\n    *\n   * @example Search groups\n   * ```ts\n   * async function searchGroupsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchGroups(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const group of result.items ?? []) {\n   *     console.log(`${group.groupId}: ${group.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchGroups\n   * @tags Group\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchGroups(input: searchGroupsInput, /** Management of eventual consistency **/ consistencyManagement: searchGroupsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchGroups>>;\n  searchGroups(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchGroupsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchGroups(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search role groups\n   *\n   * Search groups with assigned role.\n    *\n   * @example Search groups for a role\n   * ```ts\n   * async function searchGroupsForRoleExample(roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchGroupsForRole(\n   *     { roleId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const group of result.items ?? []) {\n   *     console.log(`Group: ${group.groupId}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchGroupsForRole\n   * @tags Role\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchGroupsForRole(input: searchGroupsForRoleInput, /** Management of eventual consistency **/ consistencyManagement: searchGroupsForRoleConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchGroupsForRole>>;\n  searchGroupsForRole(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchGroupsForRoleConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchGroupsForRole(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search incidents\n   *\n   * Search for incidents based on given criteria.\n   *\n    *\n   * @example Search incidents\n   * ```ts\n   * async function searchIncidentsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchIncidents(\n   *     {\n   *       filter: { state: 'ACTIVE' },\n   *       sort: [{ field: 'creationTime', order: 'DESC' }],\n   *       page: { limit: 20 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const incident of result.items ?? []) {\n   *     console.log(`${incident.incidentKey}: ${incident.errorType} — ${incident.errorMessage}`);\n   *   }\n   *   console.log(`Total active incidents: ${result.page.totalItems}`);\n   * }\n   * ```\n   * @operationId searchIncidents\n   * @tags Incident\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchIncidents(input: searchIncidentsInput, /** Management of eventual consistency **/ consistencyManagement: searchIncidentsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchIncidents>>;\n  searchIncidents(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchIncidentsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchIncidents(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search jobs\n   *\n   * Search for jobs based on given criteria.\n    *\n   * @example Search jobs\n   * ```ts\n   * async function searchJobsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchJobs(\n   *     {\n   *       filter: { type: 'payment-processing', state: 'CREATED' },\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const job of result.items ?? []) {\n   *     console.log(`Job ${job.jobKey}: ${job.type} (${job.state})`);\n   *   }\n   * }\n   * ```\n   * @operationId searchJobs\n   * @tags Job\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchJobs(input: searchJobsInput, /** Management of eventual consistency **/ consistencyManagement: searchJobsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchJobs>>;\n  searchJobs(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchJobsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchJobs(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search mapping rules\n   *\n   * Search for mapping rules based on given criteria.\n   *\n    *\n   * @example Search mapping rules\n   * ```ts\n   * async function searchMappingRulesExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchMappingRule(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const rule of result.items ?? []) {\n   *     console.log(`${rule.mappingRuleId}: ${rule.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchMappingRule\n   * @tags Mapping rule\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchMappingRule(input: searchMappingRuleInput, /** Management of eventual consistency **/ consistencyManagement: searchMappingRuleConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchMappingRule>>;\n  searchMappingRule(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchMappingRuleConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchMappingRule(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search group mapping rules\n   *\n   * Search mapping rules assigned to a group.\n    *\n   * @example Search mapping rules for a group\n   * ```ts\n   * async function searchMappingRulesForGroupExample(groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchMappingRulesForGroup(\n   *     { groupId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const rule of result.items ?? []) {\n   *     console.log(`Mapping rule: ${rule.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchMappingRulesForGroup\n   * @tags Group\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchMappingRulesForGroup(input: searchMappingRulesForGroupInput, /** Management of eventual consistency **/ consistencyManagement: searchMappingRulesForGroupConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchMappingRulesForGroup>>;\n  searchMappingRulesForGroup(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchMappingRulesForGroupConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchMappingRulesForGroup(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search role mapping rules\n   *\n   * Search mapping rules with assigned role.\n    *\n   * @example Search mapping rules for a role\n   * ```ts\n   * async function searchMappingRulesForRoleExample(roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchMappingRulesForRole(\n   *     { roleId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const rule of result.items ?? []) {\n   *     console.log(`Mapping rule: ${rule.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchMappingRulesForRole\n   * @tags Role\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchMappingRulesForRole(input: searchMappingRulesForRoleInput, /** Management of eventual consistency **/ consistencyManagement: searchMappingRulesForRoleConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchMappingRulesForRole>>;\n  searchMappingRulesForRole(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchMappingRulesForRoleConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchMappingRulesForRole(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search mapping rules for tenant\n   *\n   * Retrieves a filtered and sorted list of MappingRules for a specified tenant.\n    *\n   * @example Search mapping rules for a tenant\n   * ```ts\n   * async function searchMappingRulesForTenantExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchMappingRulesForTenant(\n   *     { tenantId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const rule of result.items ?? []) {\n   *     console.log(`Mapping rule: ${rule.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchMappingRulesForTenant\n   * @tags Tenant\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchMappingRulesForTenant(input: searchMappingRulesForTenantInput, /** Management of eventual consistency **/ consistencyManagement: searchMappingRulesForTenantConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchMappingRulesForTenant>>;\n  searchMappingRulesForTenant(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchMappingRulesForTenantConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchMappingRulesForTenant(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search message subscriptions\n   *\n   * Search for message subscriptions based on given criteria.\n   *\n   * By default, both start and intermediate event subscriptions are returned. Use the\n   * `messageSubscriptionType` filter to restrict results to a single type.\n   *\n   * **Version notes:**\n   * - Start event subscriptions are only captured for deployments made with 8.10 or later.\n   * - The `messageSubscriptionType` field is only populated for data created\n   * with Camunda 8.10 or later. For pre-8.10 data, intermediate event entries have no\n   * `messageSubscriptionType` value stored. For convenience, the API returns `PROCESS_EVENT`\n   * as a default for such search results, though.\n   * - Searching for intermediate event subscriptions **including legacy data** can be achieved\n   * by filtering for `messageSubscriptionType` not matching `START_EVENT`.\n   *\n    *\n   * @example Search message subscriptions\n   * ```ts\n   * async function searchMessageSubscriptionsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchMessageSubscriptions(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const sub of result.items ?? []) {\n   *     console.log(`Subscription: ${sub.messageName}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchMessageSubscriptions\n   * @tags Message subscription\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchMessageSubscriptions(input: searchMessageSubscriptionsInput, /** Management of eventual consistency **/ consistencyManagement: searchMessageSubscriptionsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchMessageSubscriptions>>;\n  searchMessageSubscriptions(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchMessageSubscriptionsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchMessageSubscriptions(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search own authorizations\n   *\n   * Search for the current authenticated principal's own authorization records — including authorizations granted directly to the user or client, as well as those granted via a group, role, or mapping rule the principal belongs to.\n    *\n   * @example Search own authorizations\n   * ```ts\n   * async function searchOwnAuthorizationsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchOwnAuthorizations(\n   *     {\n   *       filter: { resourceType: 'PROCESS_DEFINITION' },\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const auth of result.items ?? []) {\n   *     console.log(`${auth.resourceId}: ${auth.permissionTypes?.join(', ')}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchOwnAuthorizations\n   * @tags Authentication\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchOwnAuthorizations(input: searchOwnAuthorizationsInput, /** Management of eventual consistency **/ consistencyManagement: searchOwnAuthorizationsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchOwnAuthorizations>>;\n  searchOwnAuthorizations(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchOwnAuthorizationsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchOwnAuthorizations(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search process definitions\n   *\n   * Search for process definitions based on given criteria.\n    *\n   * @example Search process definitions\n   * ```ts\n   * async function searchProcessDefinitionsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchProcessDefinitions(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const def of result.items ?? []) {\n   *     console.log(`${def.processDefinitionKey}: ${def.processDefinitionId} v${def.version}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchProcessDefinitions\n   * @tags Process definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchProcessDefinitions(input: searchProcessDefinitionsInput, /** Management of eventual consistency **/ consistencyManagement: searchProcessDefinitionsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchProcessDefinitions>>;\n  searchProcessDefinitions(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchProcessDefinitionsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchProcessDefinitions(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search process definition variable names\n   *\n   * Search for distinct variable names defined on a process definition, optionally narrowed by the name filter.\n    *\n   * @example Search process definition variable names\n   * ```ts\n   * async function searchProcessDefinitionVariableNamesExample(\n   *   processDefinitionKey: ProcessDefinitionKey\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchProcessDefinitionVariableNames(\n   *     { processDefinitionKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const variable of result.items ?? []) {\n   *     console.log(`Variable name: ${variable.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchProcessDefinitionVariableNames\n   * @tags Process definition\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchProcessDefinitionVariableNames(input: searchProcessDefinitionVariableNamesInput, /** Management of eventual consistency **/ consistencyManagement: searchProcessDefinitionVariableNamesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchProcessDefinitionVariableNames>>;\n  searchProcessDefinitionVariableNames(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchProcessDefinitionVariableNamesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchProcessDefinitionVariableNames(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search related incidents\n   *\n   * Search for incidents caused by the process instance or any of its called process or decision instances.\n   *\n   * Although the `processInstanceKey` is provided as a path parameter to indicate the root process instance,\n   * you may also include a `processInstanceKey` within the filter object to narrow results to specific\n   * child process instances. This is useful, for example, if you want to isolate incidents associated with\n   * subprocesses or called processes under the root instance while excluding incidents directly tied to the root.\n   *\n    *\n   * @example Search process instance incidents\n   * ```ts\n   * async function searchProcessInstanceIncidentsExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchProcessInstanceIncidents(\n   *     {\n   *       processInstanceKey,\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const incident of result.items ?? []) {\n   *     console.log(`Incident: ${incident.errorType} - ${incident.errorMessage}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchProcessInstanceIncidents\n   * @tags Process instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchProcessInstanceIncidents(input: searchProcessInstanceIncidentsInput, /** Management of eventual consistency **/ consistencyManagement: searchProcessInstanceIncidentsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchProcessInstanceIncidents>>;\n  searchProcessInstanceIncidents(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchProcessInstanceIncidentsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchProcessInstanceIncidents(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search process instances\n   *\n   * Search for process instances based on given criteria.\n    *\n   * @example Search process instances\n   * ```ts\n   * async function searchProcessInstancesExample(processDefinitionId: ProcessDefinitionId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchProcessInstances(\n   *     {\n   *       filter: { processDefinitionId },\n   *       sort: [{ field: 'startDate', order: 'DESC' }],\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const instance of result.items ?? []) {\n   *     console.log(`${instance.processInstanceKey}: ${instance.state}`);\n   *   }\n   *   console.log(`Total: ${result.page.totalItems}`);\n   * }\n   * ```\n   * @operationId searchProcessInstances\n   * @tags Process instance\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchProcessInstances(input: searchProcessInstancesInput, /** Management of eventual consistency **/ consistencyManagement: searchProcessInstancesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchProcessInstances>>;\n  searchProcessInstances(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchProcessInstancesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchProcessInstances(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search resources\n   *\n   * Search for deployed resources based on given criteria.\n   * :::info\n   * This endpoint does not return BPMN process definitions, DMN decision definitions, or form\n   * resources. To query BPMN process definitions or DMN decision definitions, use their\n   * respective search APIs.\n   * :::\n   *\n    *\n   * @example Search resources\n   * ```ts\n   * async function searchResourcesExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchResources(\n   *     { page: { limit: 10 } },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const resource of result.items ?? []) {\n   *     console.log(`Resource: ${resource.resourceName}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchResources\n   * @tags Resource\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchResources(input: searchResourcesInput, /** Management of eventual consistency **/ consistencyManagement: searchResourcesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchResources>>;\n  searchResources(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchResourcesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchResources(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search roles\n   *\n   * Search for roles based on given criteria.\n    *\n   * @example Search roles\n   * ```ts\n   * async function searchRolesExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchRoles(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const role of result.items ?? []) {\n   *     console.log(`${role.roleId}: ${role.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchRoles\n   * @tags Role\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchRoles(input: searchRolesInput, /** Management of eventual consistency **/ consistencyManagement: searchRolesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchRoles>>;\n  searchRoles(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchRolesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchRoles(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search group roles\n   *\n   * Search roles assigned to a group.\n    *\n   * @example Search roles for a group\n   * ```ts\n   * async function searchRolesForGroupExample(groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchRolesForGroup(\n   *     { groupId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const role of result.items ?? []) {\n   *     console.log(`Role: ${role.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchRolesForGroup\n   * @tags Group\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchRolesForGroup(input: searchRolesForGroupInput, /** Management of eventual consistency **/ consistencyManagement: searchRolesForGroupConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchRolesForGroup>>;\n  searchRolesForGroup(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchRolesForGroupConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchRolesForGroup(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search roles for tenant\n   *\n   * Retrieves a filtered and sorted list of roles for a specified tenant.\n    *\n   * @example Search roles for a tenant\n   * ```ts\n   * async function searchRolesForTenantExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchRolesForTenant(\n   *     { tenantId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const role of result.items ?? []) {\n   *     console.log(`Role: ${role.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchRolesForTenant\n   * @tags Tenant\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchRolesForTenant(input: searchRolesForTenantInput, /** Management of eventual consistency **/ consistencyManagement: searchRolesForTenantConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchRolesForTenant>>;\n  searchRolesForTenant(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchRolesForTenantConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchRolesForTenant(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search tenants\n   *\n   * Retrieves a filtered and sorted list of tenants.\n    *\n   * @example Search tenants\n   * ```ts\n   * async function searchTenantsExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchTenants(\n   *     {\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const tenant of result.items ?? []) {\n   *     console.log(`${tenant.tenantId}: ${tenant.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchTenants\n   * @tags Tenant\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchTenants(input: searchTenantsInput, /** Management of eventual consistency **/ consistencyManagement: searchTenantsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchTenants>>;\n  searchTenants(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchTenantsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchTenants(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search users\n   *\n   * Search for users based on given criteria.\n    *\n   * @example Search users\n   * ```ts\n   * async function searchUsersExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchUsers(\n   *     {\n   *       filter: {},\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const user of result.items ?? []) {\n   *     console.log(`${user.username}: ${user.name}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchUsers\n   * @tags User\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchUsers(input: searchUsersInput, /** Management of eventual consistency **/ consistencyManagement: searchUsersConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchUsers>>;\n  searchUsers(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchUsersConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchUsers(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search group users\n   *\n   * Search users assigned to a group.\n    *\n   * @example Search users in a group\n   * ```ts\n   * async function searchUsersForGroupExample(groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchUsersForGroup(\n   *     { groupId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const user of result.items ?? []) {\n   *     console.log(`Member: ${user.username}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchUsersForGroup\n   * @tags Group\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchUsersForGroup(input: searchUsersForGroupInput, /** Management of eventual consistency **/ consistencyManagement: searchUsersForGroupConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchUsersForGroup>>;\n  searchUsersForGroup(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchUsersForGroupConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchUsersForGroup(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search role users\n   *\n   * Search users with assigned role.\n    *\n   * @example Search users for a role\n   * ```ts\n   * async function searchUsersForRoleExample(roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchUsersForRole(\n   *     { roleId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const user of result.items ?? []) {\n   *     console.log(`User: ${user.username}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchUsersForRole\n   * @tags Role\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchUsersForRole(input: searchUsersForRoleInput, /** Management of eventual consistency **/ consistencyManagement: searchUsersForRoleConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchUsersForRole>>;\n  searchUsersForRole(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchUsersForRoleConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchUsersForRole(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search users for tenant\n   *\n   * Retrieves a filtered and sorted list of users for a specified tenant.\n    *\n   * @example Search users for a tenant\n   * ```ts\n   * async function searchUsersForTenantExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchUsersForTenant(\n   *     { tenantId },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const user of result.items ?? []) {\n   *     console.log(`Tenant member: ${user.username}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchUsersForTenant\n   * @tags Tenant\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchUsersForTenant(input: searchUsersForTenantInput, /** Management of eventual consistency **/ consistencyManagement: searchUsersForTenantConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchUsersForTenant>>;\n  searchUsersForTenant(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchUsersForTenantConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchUsersForTenant(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search user task audit logs\n   *\n   * Search for user task audit logs based on given criteria.\n    *\n   * @example Search user task audit logs\n   * ```ts\n   * async function searchUserTaskAuditLogsExample(userTaskKey: UserTaskKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchUserTaskAuditLogs(\n   *     { userTaskKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const log of result.items ?? []) {\n   *     console.log(`Audit: ${log.operationType} at ${log.timestamp}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchUserTaskAuditLogs\n   * @tags User task\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchUserTaskAuditLogs(input: searchUserTaskAuditLogsInput, /** Management of eventual consistency **/ consistencyManagement: searchUserTaskAuditLogsConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchUserTaskAuditLogs>>;\n  searchUserTaskAuditLogs(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchUserTaskAuditLogsConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchUserTaskAuditLogs(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search user task effective variables\n   *\n   * Search for the effective variables of a user task. This endpoint returns deduplicated\n   * variables where each variable name appears at most once. When the same variable name exists\n   * at multiple scope levels in the scope hierarchy, the value from the innermost scope (closest\n   * to the user task) takes precedence. This is useful for retrieving the actual runtime state\n   * of variables as seen by the user task. By default, long variable values in the response are\n   * truncated.\n   *\n    *\n   * @example Search user task effective variables\n   * ```ts\n   * async function searchUserTaskEffectiveVariablesExample(userTaskKey: UserTaskKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchUserTaskEffectiveVariables(\n   *     { userTaskKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const variable of result.items ?? []) {\n   *     console.log(`${variable.name} = ${variable.value}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchUserTaskEffectiveVariables\n   * @tags User task\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchUserTaskEffectiveVariables(input: searchUserTaskEffectiveVariablesInput, /** Management of eventual consistency **/ consistencyManagement: searchUserTaskEffectiveVariablesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchUserTaskEffectiveVariables>>;\n  searchUserTaskEffectiveVariables(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchUserTaskEffectiveVariablesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchUserTaskEffectiveVariables(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search user tasks\n   *\n   * Search for user tasks based on given criteria.\n    *\n   * @example Search user tasks\n   * ```ts\n   * async function searchUserTasksExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchUserTasks(\n   *     {\n   *       filter: { assignee: 'alice', state: 'CREATED' },\n   *       sort: [{ field: 'creationDate', order: 'DESC' }],\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const task of result.items ?? []) {\n   *     console.log(`${task.userTaskKey}: ${task.name} (${task.state})`);\n   *   }\n   * }\n   * ```\n   * @operationId searchUserTasks\n   * @tags User task\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchUserTasks(input: searchUserTasksInput, /** Management of eventual consistency **/ consistencyManagement: searchUserTasksConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchUserTasks>>;\n  searchUserTasks(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchUserTasksConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchUserTasks(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search user task variables\n   *\n   * Search for user task variables based on given criteria. This endpoint returns all variable\n   * documents visible from the user task's scope, including variables from parent scopes in the\n   * scope hierarchy. If the same variable name exists at multiple scope levels, each scope's\n   * variable is returned as a separate result. Use the\n   * `/user-tasks/{userTaskKey}/effective-variables/search` endpoint to get deduplicated variables\n   * where the innermost scope takes precedence. By default, long variable values in the response\n   * are truncated.\n   *\n    *\n   * @example Search user task variables\n   * ```ts\n   * async function searchUserTaskVariablesExample(userTaskKey: UserTaskKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchUserTaskVariables(\n   *     { userTaskKey },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const variable of result.items ?? []) {\n   *     console.log(`${variable.name} = ${variable.value}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchUserTaskVariables\n   * @tags User task\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchUserTaskVariables(input: searchUserTaskVariablesInput, /** Management of eventual consistency **/ consistencyManagement: searchUserTaskVariablesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchUserTaskVariables>>;\n  searchUserTaskVariables(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchUserTaskVariablesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchUserTaskVariables(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Search variables\n   *\n   * Search for variables based on given criteria.\n   *\n   * This endpoint returns variables that exist directly at the specified scopes - it does not\n   * include variables from parent scopes that would be visible through the scope hierarchy.\n   *\n   * Variables can be process-level (scoped to the process instance) or local (scoped to specific\n   * BPMN elements like tasks, subprocesses, etc.).\n   *\n   * By default, long variable values in the response are truncated.\n    *\n   * @example Search variables\n   * ```ts\n   * async function searchVariablesExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.searchVariables(\n   *     {\n   *       filter: {\n   *         processInstanceKey,\n   *       },\n   *       page: { limit: 10 },\n   *     },\n   *     { consistency: { waitUpToMs: 5000 } }\n   *   );\n   * \n   *   for (const variable of result.items ?? []) {\n   *     console.log(`${variable.name} = ${variable.value}`);\n   *   }\n   * }\n   * ```\n   * @operationId searchVariables\n   * @tags Variable\n   * @consistency eventual - this endpoint is backed by data that is eventually consistent with the system state.\n   */\n  searchVariables(input: searchVariablesInput, /** Management of eventual consistency **/ consistencyManagement: searchVariablesConsistency, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.searchVariables>>;\n  searchVariables(arg: any, /** Management of eventual consistency **/ consistencyManagement: searchVariablesConsistency, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.searchVariables(this, arg, consistencyManagement, options);\n  }\n\n  /**\n   * Suspend Batch operation\n   *\n   * Suspends a running batch operation.\n   * This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Suspend a batch operation\n   * ```ts\n   * async function suspendBatchOperationExample(batchOperationKey: BatchOperationKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.suspendBatchOperation({ batchOperationKey });\n   * }\n   * ```\n   * @operationId suspendBatchOperation\n   * @tags Batch operation\n   */\n  suspendBatchOperation(input: suspendBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.suspendBatchOperation>>;\n  suspendBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.suspendBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Suspend process instance\n   *\n   * Suspends a running process instance, pausing further processing until it is resumed.\n   * Only process instances in the ACTIVE state can be suspended.\n   * A child process instance can be suspended independently of its parent or root process\n   * instance; suspension does not cascade to or from related instances.\n   *\n    *\n   * @example Suspend a process instance\n   * ```ts\n   * async function suspendProcessInstanceExample(processInstanceKey: ProcessInstanceKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.suspendProcessInstance({ processInstanceKey });\n   * }\n   * ```\n   * @operationId suspendProcessInstance\n   * @tags Process instance\n   */\n  suspendProcessInstance(input: suspendProcessInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.suspendProcessInstance>>;\n  suspendProcessInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.suspendProcessInstance(this, arg, options);\n  }\n\n  /**\n   * Suspend process instances (batch)\n   *\n   * Suspends multiple running process instances.\n   * Any given filter for state or parentProcessInstanceKey is ignored and overridden, as only\n   * ACTIVE process instances can be suspended and suspension does not cascade between parent\n   * and child instances, so child instances are suspended independently of their parent or\n   * root instance.\n   * This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Suspend process instances in batch\n   * ```ts\n   * async function suspendProcessInstancesBatchOperationExample(\n   *   processDefinitionKey: ProcessDefinitionKey\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.suspendProcessInstancesBatchOperation({\n   *     filter: {\n   *       processDefinitionKey,\n   *     },\n   *   });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId suspendProcessInstancesBatchOperation\n   * @tags Process instance\n   */\n  suspendProcessInstancesBatchOperation(input: suspendProcessInstancesBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.suspendProcessInstancesBatchOperation>>;\n  suspendProcessInstancesBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.suspendProcessInstancesBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Force-write runtime backup state\n   *\n   * Force-writes the checkpoint and backup metadata of every partition of the physical\n   * tenant to the backup store, independent of any backup being taken or confirmed, and\n   * returns the updated state.\n   *\n    *\n   * @example Force-write the runtime backup state\n   * ```ts\n   * async function syncRuntimeBackupStateExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Force-writes checkpoint and backup metadata of every partition to the backup\n   *   // store, independent of any backup being taken, and returns the updated state.\n   *   const state = await camunda.syncRuntimeBackupState();\n   * \n   *   console.log(`Synced ${state.backupStates.length} partition backup states`);\n   * }\n   * ```\n   * @operationId syncRuntimeBackupState\n   * @tags Backup\n   */\n  syncRuntimeBackupState(options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.syncRuntimeBackupState>>;\n  syncRuntimeBackupState(arg?: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.syncRuntimeBackupState(this, options);\n  }\n\n  /**\n   * Force-write runtime backup state across physical tenants\n   *\n   * Force-writes the checkpoint and backup metadata of every partition of every physical tenant of the cluster, or of the one named by `physicalTenantId`, to that tenant's backup store, independent of any backup being taken or confirmed, and returns the updated state per physical tenant.\n   *\n   * The request is all-or-nothing: a physical tenant whose metadata cannot be written fails the whole request, and the writes that already succeeded on other tenants are not undone. The operation is idempotent, so retrying the same call is the correct remedy. Narrow the request with `physicalTenantId` to write the tenants that can still be reached.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Use `POST /v2/backups/runtime/state/sync` to act as a single physical tenant.\n    *\n   * @example Force-write the runtime backup state (cluster admin)\n   * ```ts\n   * async function syncRuntimeBackupStateAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Force-writes checkpoint and backup metadata of every partition to the backup\n   *   // store on every targeted physical tenant, independent of any backup being\n   *   // taken, and returns the updated per-tenant state.\n   *   const clusterState = await camunda.syncRuntimeBackupStateAsClusterAdmin({});\n   * \n   *   console.log(`Synced ${clusterState.physicalTenants.length} physical tenants`);\n   * }\n   * ```\n   * @operationId syncRuntimeBackupStateAsClusterAdmin\n   * @tags Backup\n   */\n  syncRuntimeBackupStateAsClusterAdmin(input: syncRuntimeBackupStateAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.syncRuntimeBackupStateAsClusterAdmin>>;\n  syncRuntimeBackupStateAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.syncRuntimeBackupStateAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Take a history backup\n   *\n   * Triggers a backup of the physical tenant's history, by scheduling a snapshot of every\n   * secondary storage index it owns.\n   *\n   * Unlike runtime backups, history backups have no generated-id mode: `backupId` is always\n   * required.\n   *\n   * Only available on clusters whose secondary storage is Elasticsearch or OpenSearch.\n   *\n    *\n   * @example Take a history backup\n   * ```ts\n   * async function takeHistoryBackupExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Backups are logically ordered by id, so each successive backup must use a\n   *   // higher id than the previous one.\n   *   const backup = await camunda.takeHistoryBackup({ backupId: 100 });\n   * \n   *   console.log(`Scheduled history backup ${backup.backupId}`);\n   *   for (const snapshot of backup.scheduledSnapshots) {\n   *     console.log(`  ${snapshot}`);\n   *   }\n   * }\n   * ```\n   * @operationId takeHistoryBackup\n   * @tags Backup\n   */\n  takeHistoryBackup(input: takeHistoryBackupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.takeHistoryBackup>>;\n  takeHistoryBackup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.takeHistoryBackup(this, arg, options);\n  }\n\n  /**\n   * Take a history backup on one or every physical tenant\n   *\n   * Triggers a history backup on every physical tenant of the cluster, or on the one named by `physicalTenantId`. Every targeted tenant uses the same caller-supplied `backupId`, but the backups are independent: they are neither coordinated nor rolled back together.\n   *\n   * The request is all-or-nothing: the `backupId` is checked on every targeted tenant before any snapshot is scheduled, so a tenant that already holds this id, or that cannot be reached, fails the whole request and no backup is started anywhere. There is no aggregated cluster-level state in the response.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Only available on clusters whose secondary storage is Elasticsearch or OpenSearch. Use `POST /v2/backups/history` to act as a single physical tenant.\n    *\n   * @example Take a history backup (cluster admin)\n   * ```ts\n   * async function takeHistoryBackupAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Cluster-admin variant: fans the backup out to every physical tenant of the\n   *   // cluster (or a single one when `physicalTenantId` is given). Requires a\n   *   // separate cluster-admin security chain — Orchestration Cluster user\n   *   // credentials are NOT accepted. Each backup must use a higher id than the last.\n   *   const backup = await camunda.takeHistoryBackupAsClusterAdmin({ backupId: 100 });\n   * \n   *   console.log(`Scheduled cluster history backup ${backup.backupId}`);\n   *   for (const tenant of backup.physicalTenants) {\n   *     console.log(\n   *       `  [${tenant.physicalTenantId}] scheduled ${tenant.scheduledSnapshots.length} snapshots`\n   *     );\n   *   }\n   * }\n   * ```\n   * @operationId takeHistoryBackupAsClusterAdmin\n   * @tags Backup\n   */\n  takeHistoryBackupAsClusterAdmin(input: takeHistoryBackupAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.takeHistoryBackupAsClusterAdmin>>;\n  takeHistoryBackupAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.takeHistoryBackupAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Take a runtime backup\n   *\n   * Triggers a backup of runtime data on all partitions of the physical tenant.\n   *\n   * The `backupId` must be omitted if continuous backups and/or a backup or checkpoint\n   * schedule is enabled for the physical tenant, as the id is generated automatically.\n   * Otherwise, `backupId` is required.\n   *\n    *\n   * @example Take a runtime backup\n   * ```ts\n   * async function takeRuntimeBackupExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Omit `backupId` when continuous backups or a backup/checkpoint schedule is\n   *   // enabled for the physical tenant — the id is then generated by the cluster.\n   *   // Otherwise `backupId` is required and must be higher than any existing one.\n   *   const backup = await camunda.takeRuntimeBackup({ backupId: 100 });\n   * \n   *   console.log(`Scheduled backup ${backup.backupId}`);\n   * }\n   * ```\n   * @operationId takeRuntimeBackup\n   * @tags Backup\n   */\n  takeRuntimeBackup(input: takeRuntimeBackupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.takeRuntimeBackup>>;\n  takeRuntimeBackup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.takeRuntimeBackup(this, arg, options);\n  }\n\n  /**\n   * Take a runtime backup on one or every physical tenant\n   *\n   * Triggers a runtime backup on every physical tenant of the cluster, or on the one named by `physicalTenantId`. A cluster-wide backup is a set of independent per-tenant backups, not an atomic snapshot of the cluster: they are neither coordinated nor rolled back together, and each tenant stores its own, so the same `backupId` can be used for all of them.\n   *\n   * Every targeted physical tenant must be in the same backup-id mode. `backupId` must be omitted when every targeted tenant generates its own ids (because continuous backups and/or a backup or checkpoint schedule is enabled for it), and is required when none of them does. A cluster whose targeted tenants mix the two modes is rejected with 400 and has to be driven one tenant at a time through `POST /v2/backups/runtime`. In generated-id mode each tenant generates its own id, so the response reports an id per physical tenant rather than one for the cluster.\n   *\n   * The trigger is all-or-error, and never silent about a partial trigger: if any targeted tenant cannot be triggered the response carries an error status, but its body still lists every targeted tenant — which ones were triggered, under which `backupId` to monitor or delete them, and why the others failed. Nothing is rolled back, so the backups that were triggered keep running and have to be deleted explicitly. A request rejected before any tenant was triggered answers with a problem detail instead, and nothing is running.\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here. Use `POST /v2/backups/runtime` to act as a single physical tenant.\n    *\n   * @example Take a runtime backup (cluster admin)\n   * ```ts\n   * async function takeRuntimeBackupAsClusterAdminExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   // Cluster-admin variant: triggers a runtime backup on every physical tenant of\n   *   // the cluster (or a single one when `physicalTenantId` is given). Requires the\n   *   // separate cluster-admin security chain — Orchestration Cluster user\n   *   // credentials are NOT accepted. Passing an explicit `backupId` is manual-id\n   *   // mode: every targeted tenant must share that id (omit it for generated-id\n   *   // mode, where each tenant generates its own). Either way the response lists the\n   *   // outcome per physical tenant rather than cluster-wide.\n   *   const backup = await camunda.takeRuntimeBackupAsClusterAdmin({ backupId: 100 });\n   * \n   *   for (const tenant of backup.physicalTenants) {\n   *     console.log(`[${tenant.physicalTenantId}] ${tenant.outcome} (backupId ${tenant.backupId})`);\n   *   }\n   * }\n   * ```\n   * @operationId takeRuntimeBackupAsClusterAdmin\n   * @tags Backup\n   */\n  takeRuntimeBackupAsClusterAdmin(input: takeRuntimeBackupAsClusterAdminInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.takeRuntimeBackupAsClusterAdmin>>;\n  takeRuntimeBackupAsClusterAdmin(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.takeRuntimeBackupAsClusterAdmin(this, arg, options);\n  }\n\n  /**\n   * Throw error for job\n   *\n   * Reports a business error (i.e. non-technical) that occurs while processing a job.\n   *\n    *\n   * @example Throw a job error\n   * ```ts\n   * async function throwJobErrorExample(jobKey: JobKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.throwJobError({\n   *     jobKey,\n   *     errorCode: 'PAYMENT_FAILED',\n   *     errorMessage: 'Payment provider returned error',\n   *   });\n   * }\n   * ```\n   * @operationId throwJobError\n   * @tags Job\n   */\n  throwJobError(input: throwJobErrorInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.throwJobError>>;\n  throwJobError(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.throwJobError(this, arg, options);\n  }\n\n  /**\n   * Trigger a cluster-wide leadership rebalance\n   *\n   * Transfers leadership of every partition that is not led by its highest-priority replica towards that replica, one partition at a time. Returns as soon as the rebalance has been accepted (poll `GET /cluster/v2/rebalance` to monitor progress).\n   *\n   * Each rebalance can specify overrides for the configured rebalance settings (e.g. maximum replication lag to allow). An absent request body means \"use the configured settings\".\n   *\n   * Requires the cluster-admin security chain. Although this operation lists `bearerAuth` / `basicAuth` like the rest of the Orchestration Cluster API, it does not accept an Orchestration Cluster user's credentials — only the separate cluster-admin credentials are valid here.\n    *\n   * @example Trigger a cluster-wide leadership rebalance\n   * ```ts\n   * async function triggerClusterRebalanceExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const balance = await camunda.triggerClusterRebalance({\n   *     replicationLagThreshold: 10_000_000,\n   *     maxTransferAttempts: 3,\n   *   });\n   * \n   *   console.log(`Cluster balance state: ${balance.state}`);\n   *   if (balance.runningRebalance) {\n   *     console.log(`Rebalance started: id=${balance.runningRebalance.rebalanceId}`);\n   *   }\n   * }\n   * ```\n   * @operationId triggerClusterRebalance\n   * @tags Cluster\n   */\n  triggerClusterRebalance(input: triggerClusterRebalanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.triggerClusterRebalance>>;\n  triggerClusterRebalance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.triggerClusterRebalance(this, arg, options);\n  }\n\n  /**\n   * Unassign a client from a group\n   *\n   * Unassigns a client from a group.\n   * The client is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.\n   *\n    *\n   * @example Unassign a client from a group\n   * ```ts\n   * async function unassignClientFromGroupExample(groupId: GroupId, clientId: ClientId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignClientFromGroup({\n   *     groupId,\n   *     clientId,\n   *   });\n   * }\n   * ```\n   * @operationId unassignClientFromGroup\n   * @tags Group\n   */\n  unassignClientFromGroup(input: unassignClientFromGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignClientFromGroup>>;\n  unassignClientFromGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignClientFromGroup(this, arg, options);\n  }\n\n  /**\n   * Unassign a client from a tenant\n   *\n   * Unassigns the client from the specified tenant.\n   * The client can no longer access tenant data.\n   *\n    *\n   * @example Unassign a client from a tenant\n   * ```ts\n   * async function unassignClientFromTenantExample(tenantId: TenantId, clientId: ClientId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignClientFromTenant({\n   *     tenantId,\n   *     clientId,\n   *   });\n   * }\n   * ```\n   * @operationId unassignClientFromTenant\n   * @tags Tenant\n   */\n  unassignClientFromTenant(input: unassignClientFromTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignClientFromTenant>>;\n  unassignClientFromTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignClientFromTenant(this, arg, options);\n  }\n\n  /**\n   * Unassign a group from a tenant\n   *\n   * Unassigns a group from a specified tenant.\n   * Members of the group (users, clients) will no longer have access to the tenant's data - except they are assigned directly to the tenant.\n   *\n    *\n   * @example Unassign a group from a tenant\n   * ```ts\n   * async function unassignGroupFromTenantExample(tenantId: TenantId, groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignGroupFromTenant({\n   *     tenantId,\n   *     groupId,\n   *   });\n   * }\n   * ```\n   * @operationId unassignGroupFromTenant\n   * @tags Tenant\n   */\n  unassignGroupFromTenant(input: unassignGroupFromTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignGroupFromTenant>>;\n  unassignGroupFromTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignGroupFromTenant(this, arg, options);\n  }\n\n  /**\n   * Unassign a mapping rule from a group\n   *\n   * Unassigns a mapping rule from a group.\n    *\n   * @example Unassign a mapping rule from a group\n   * ```ts\n   * async function unassignMappingRuleFromGroupExample(groupId: GroupId, mappingRuleId: MappingRuleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignMappingRuleFromGroup({\n   *     groupId,\n   *     mappingRuleId,\n   *   });\n   * }\n   * ```\n   * @operationId unassignMappingRuleFromGroup\n   * @tags Group\n   */\n  unassignMappingRuleFromGroup(input: unassignMappingRuleFromGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignMappingRuleFromGroup>>;\n  unassignMappingRuleFromGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignMappingRuleFromGroup(this, arg, options);\n  }\n\n  /**\n   * Unassign a mapping rule from a tenant\n   *\n   * Unassigns a single mapping rule from a specified tenant without deleting the rule.\n    *\n   * @example Unassign a mapping rule from a tenant\n   * ```ts\n   * async function unassignMappingRuleFromTenantExample(\n   *   tenantId: TenantId,\n   *   mappingRuleId: MappingRuleId\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignMappingRuleFromTenant({\n   *     tenantId,\n   *     mappingRuleId,\n   *   });\n   * }\n   * ```\n   * @operationId unassignMappingRuleFromTenant\n   * @tags Tenant\n   */\n  unassignMappingRuleFromTenant(input: unassignMappingRuleFromTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignMappingRuleFromTenant>>;\n  unassignMappingRuleFromTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignMappingRuleFromTenant(this, arg, options);\n  }\n\n  /**\n   * Unassign a role from a client\n   *\n   * Unassigns the specified role from the client. The client will no longer inherit the authorizations associated with this role.\n    *\n   * @example Unassign a role from a client\n   * ```ts\n   * async function unassignRoleFromClientExample(roleId: RoleId, clientId: ClientId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignRoleFromClient({\n   *     roleId,\n   *     clientId,\n   *   });\n   * }\n   * ```\n   * @operationId unassignRoleFromClient\n   * @tags Role\n   */\n  unassignRoleFromClient(input: unassignRoleFromClientInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignRoleFromClient>>;\n  unassignRoleFromClient(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignRoleFromClient(this, arg, options);\n  }\n\n  /**\n   * Unassign a role from a group\n   *\n   * Unassigns the specified role from the group. All group members (user or client) no longer inherit the authorizations associated with this role.\n    *\n   * @example Unassign a role from a group\n   * ```ts\n   * async function unassignRoleFromGroupExample(roleId: RoleId, groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignRoleFromGroup({\n   *     roleId,\n   *     groupId,\n   *   });\n   * }\n   * ```\n   * @operationId unassignRoleFromGroup\n   * @tags Role\n   */\n  unassignRoleFromGroup(input: unassignRoleFromGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignRoleFromGroup>>;\n  unassignRoleFromGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignRoleFromGroup(this, arg, options);\n  }\n\n  /**\n   * Unassign a role from a mapping rule\n   *\n   * Unassigns a role from a mapping rule.\n    *\n   * @example Unassign a role from a mapping rule\n   * ```ts\n   * async function unassignRoleFromMappingRuleExample(roleId: RoleId, mappingRuleId: MappingRuleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignRoleFromMappingRule({\n   *     roleId,\n   *     mappingRuleId,\n   *   });\n   * }\n   * ```\n   * @operationId unassignRoleFromMappingRule\n   * @tags Role\n   */\n  unassignRoleFromMappingRule(input: unassignRoleFromMappingRuleInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignRoleFromMappingRule>>;\n  unassignRoleFromMappingRule(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignRoleFromMappingRule(this, arg, options);\n  }\n\n  /**\n   * Unassign a role from a tenant\n   *\n   * Unassigns a role from a specified tenant.\n   * Users, Clients or Groups, that have the role assigned, will no longer have access to the\n   * tenant's data - unless they are assigned directly to the tenant.\n   *\n    *\n   * @example Unassign a role from a tenant\n   * ```ts\n   * async function unassignRoleFromTenantExample(tenantId: TenantId, roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignRoleFromTenant({\n   *     tenantId,\n   *     roleId,\n   *   });\n   * }\n   * ```\n   * @operationId unassignRoleFromTenant\n   * @tags Tenant\n   */\n  unassignRoleFromTenant(input: unassignRoleFromTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignRoleFromTenant>>;\n  unassignRoleFromTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignRoleFromTenant(this, arg, options);\n  }\n\n  /**\n   * Unassign a role from a user\n   *\n   * Unassigns a role from a user. The user will no longer inherit the authorizations associated with this role.\n    *\n   * @example Unassign a role from a user\n   * ```ts\n   * async function unassignRoleFromUserExample(roleId: RoleId, username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignRoleFromUser({\n   *     roleId,\n   *     username,\n   *   });\n   * }\n   * ```\n   * @operationId unassignRoleFromUser\n   * @tags Role\n   */\n  unassignRoleFromUser(input: unassignRoleFromUserInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignRoleFromUser>>;\n  unassignRoleFromUser(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignRoleFromUser(this, arg, options);\n  }\n\n  /**\n   * Unassign a user from a group\n   *\n   * Unassigns a user from a group.\n   * The user is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.\n   *\n    *\n   * @example Unassign a user from a group\n   * ```ts\n   * async function unassignUserFromGroupExample(groupId: GroupId, username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignUserFromGroup({\n   *     groupId,\n   *     username,\n   *   });\n   * }\n   * ```\n   * @operationId unassignUserFromGroup\n   * @tags Group\n   */\n  unassignUserFromGroup(input: unassignUserFromGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignUserFromGroup>>;\n  unassignUserFromGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignUserFromGroup(this, arg, options);\n  }\n\n  /**\n   * Unassign a user from a tenant\n   *\n   * Unassigns the user from the specified tenant.\n   * The user can no longer access tenant data.\n   *\n    *\n   * @example Unassign a user from a tenant\n   * ```ts\n   * async function unassignUserFromTenantExample(tenantId: TenantId, username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignUserFromTenant({\n   *     tenantId,\n   *     username,\n   *   });\n   * }\n   * ```\n   * @operationId unassignUserFromTenant\n   * @tags Tenant\n   */\n  unassignUserFromTenant(input: unassignUserFromTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignUserFromTenant>>;\n  unassignUserFromTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignUserFromTenant(this, arg, options);\n  }\n\n  /**\n   * Unassign user task\n   *\n   * Removes the assignee of a task with the given key. Unassignment waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.\n   *\n    *\n   * @example Unassign a user task\n   * ```ts\n   * async function unassignUserTaskExample(userTaskKey: UserTaskKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.unassignUserTask({ userTaskKey });\n   * }\n   * ```\n   * @operationId unassignUserTask\n   * @tags User task\n   */\n  unassignUserTask(input: unassignUserTaskInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.unassignUserTask>>;\n  unassignUserTask(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.unassignUserTask(this, arg, options);\n  }\n\n  /**\n   * Update agent instance\n   *\n   * Updates the status of an agent instance and appends a batch of history items\n   * to its conversation history. Each history item created for this request is\n   * echoed back in the response.\n   *\n    *\n   * @example Update an agent instance\n   * ```ts\n   * async function updateAgentInstanceExample(\n   *   agentInstanceKey: AgentInstanceKey,\n   *   elementInstanceKey: ElementInstanceKey,\n   *   jobKey: JobKey,\n   *   jobLeaseToken: JobLeaseToken\n   * ) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateAgentInstance({\n   *     agentInstanceKey,\n   *     elementInstanceKey,\n   *     jobKey,\n   *     jobLeaseToken,\n   *     status: 'THINKING',\n   *     history: [\n   *       {\n   *         historyItemId: HistoryItemId.assumeExists('assistant-1'),\n   *         loopIteration: 1,\n   *         role: 'ASSISTANT',\n   *         content: [{ contentType: 'TEXT', text: 'How can I help you?' }],\n   *         producedAt: new Date().toISOString(),\n   *         metrics: { inputTokens: 150, outputTokens: 50, durationMs: 820 },\n   *       },\n   *     ],\n   *   });\n   * \n   *   console.log(`Updated agent instance: ${agentInstanceKey}`);\n   * }\n   * ```\n   * @operationId updateAgentInstance\n   * @tags Agent instance\n   */\n  updateAgentInstance(input: updateAgentInstanceInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateAgentInstance>>;\n  updateAgentInstance(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateAgentInstance(this, arg, options);\n  }\n\n  /**\n   * Update authorization\n   *\n   * Update the authorization with the given key.\n    *\n   * @example Update an authorization\n   * ```ts\n   * async function updateAuthorizationExample(authorizationKey: AuthorizationKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateAuthorization({\n   *     authorizationKey,\n   *     ownerId: 'user-123',\n   *     ownerType: 'USER',\n   *     resourceId: 'order-process',\n   *     resourceType: 'PROCESS_DEFINITION',\n   *     permissionTypes: [\n   *       'CREATE_PROCESS_INSTANCE',\n   *       'READ_PROCESS_INSTANCE',\n   *       'DELETE_PROCESS_INSTANCE',\n   *     ],\n   *   });\n   * }\n   * ```\n   * @operationId updateAuthorization\n   * @tags Authorization\n   */\n  updateAuthorization(input: updateAuthorizationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateAuthorization>>;\n  updateAuthorization(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateAuthorization(this, arg, options);\n  }\n\n  /**\n   * Update a global-scoped cluster variable\n   *\n   * Updates the value of an existing global cluster variable.\n   * The variable must exist, otherwise a 404 error is returned.\n   *\n    *\n   * @example Update a global cluster variable\n   * ```ts\n   * async function updateGlobalClusterVariableExample(name: ClusterVariableName) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateGlobalClusterVariable({\n   *     name,\n   *     value: { darkMode: false },\n   *   });\n   * }\n   * ```\n   * @operationId updateGlobalClusterVariable\n   * @tags Cluster Variable\n   */\n  updateGlobalClusterVariable(input: updateGlobalClusterVariableInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateGlobalClusterVariable>>;\n  updateGlobalClusterVariable(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateGlobalClusterVariable(this, arg, options);\n  }\n\n  /**\n   * Update global user task listener\n   *\n   * Updates a global user task listener.\n    *\n   * @example Update a global task listener\n   * ```ts\n   * async function updateGlobalTaskListenerExample(id: GlobalListenerId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateGlobalTaskListener({\n   *     id,\n   *     eventTypes: ['completing'],\n   *     type: 'updated-audit-listener',\n   *   });\n   * }\n   * ```\n   * @operationId updateGlobalTaskListener\n   * @tags Global listener\n   */\n  updateGlobalTaskListener(input: updateGlobalTaskListenerInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateGlobalTaskListener>>;\n  updateGlobalTaskListener(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateGlobalTaskListener(this, arg, options);\n  }\n\n  /**\n   * Update group\n   *\n   * Update a group with the given ID.\n    *\n   * @example Update a group\n   * ```ts\n   * async function updateGroupExample(groupId: GroupId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateGroup({\n   *     groupId,\n   *     name: 'Engineering Team',\n   *   });\n   * }\n   * ```\n   * @operationId updateGroup\n   * @tags Group\n   */\n  updateGroup(input: updateGroupInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateGroup>>;\n  updateGroup(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateGroup(this, arg, options);\n  }\n\n  /**\n   * Update job\n   *\n   * Update a job with the given key.\n    *\n   * @example Update a job\n   * ```ts\n   * async function updateJobExample(jobKey: JobKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateJob({\n   *     jobKey,\n   *     changeset: { retries: 5, timeout: 60000 },\n   *   });\n   * }\n   * ```\n   * @operationId updateJob\n   * @tags Job\n   */\n  updateJob(input: updateJobInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateJob>>;\n  updateJob(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateJob(this, arg, options);\n  }\n\n  /**\n   * Update jobs (batch)\n   *\n   * Creates a batch operation to update jobs matching the given filter. At least one changeset field must be non-null. This is done asynchronously; the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).\n   *\n    *\n   * @example Update jobs in batch\n   * ```ts\n   * async function updateJobsBatchOperationExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const result = await camunda.updateJobsBatchOperation({\n   *     filter: {\n   *       type: 'payment-processing',\n   *       hasFailedWithRetriesLeft: false,\n   *     },\n   *     changeset: {\n   *       retries: 3,\n   *     },\n   *   });\n   * \n   *   console.log(`Batch operation key: ${result.batchOperationKey}`);\n   * }\n   * ```\n   * @operationId updateJobsBatchOperation\n   * @tags Job\n   */\n  updateJobsBatchOperation(input: updateJobsBatchOperationInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateJobsBatchOperation>>;\n  updateJobsBatchOperation(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateJobsBatchOperation(this, arg, options);\n  }\n\n  /**\n   * Update mapping rule\n   *\n   * Update a mapping rule.\n   *\n    *\n   * @example Update a mapping rule\n   * ```ts\n   * async function updateMappingRuleExample(mappingRuleId: MappingRuleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateMappingRule({\n   *     mappingRuleId,\n   *     name: 'LDAP Group Mapping',\n   *     claimName: 'groups',\n   *     claimValue: 'engineering-team',\n   *   });\n   * }\n   * ```\n   * @operationId updateMappingRule\n   * @tags Mapping rule\n   */\n  updateMappingRule(input: updateMappingRuleInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateMappingRule>>;\n  updateMappingRule(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateMappingRule(this, arg, options);\n  }\n\n  /**\n   * Update role\n   *\n   * Update a role with the given ID.\n    *\n   * @example Update a role\n   * ```ts\n   * async function updateRoleExample(roleId: RoleId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateRole({\n   *     roleId,\n   *     name: 'Process Administrator',\n   *   });\n   * }\n   * ```\n   * @operationId updateRole\n   * @tags Role\n   */\n  updateRole(input: updateRoleInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateRole>>;\n  updateRole(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateRole(this, arg, options);\n  }\n\n  /**\n   * Update tenant\n   *\n   * Updates an existing tenant.\n    *\n   * @example Update a tenant\n   * ```ts\n   * async function updateTenantExample(tenantId: TenantId) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateTenant({\n   *     tenantId,\n   *     name: 'Customer Service Team',\n   *   });\n   * }\n   * ```\n   * @operationId updateTenant\n   * @tags Tenant\n   */\n  updateTenant(input: updateTenantInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateTenant>>;\n  updateTenant(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateTenant(this, arg, options);\n  }\n\n  /**\n   * Update a tenant-scoped cluster variable\n   *\n   * Updates the value of an existing tenant-scoped cluster variable.\n   * The variable must exist, otherwise a 404 error is returned.\n   *\n    *\n   * @example Update a tenant cluster variable\n   * ```ts\n   * async function updateTenantClusterVariableExample(tenantId: TenantId, name: ClusterVariableName) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateTenantClusterVariable({\n   *     tenantId,\n   *     name,\n   *     value: { region: 'eu-west-1' },\n   *   });\n   * }\n   * ```\n   * @operationId updateTenantClusterVariable\n   * @tags Cluster Variable\n   */\n  updateTenantClusterVariable(input: updateTenantClusterVariableInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateTenantClusterVariable>>;\n  updateTenantClusterVariable(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateTenantClusterVariable(this, arg, options);\n  }\n\n  /**\n   * Update user\n   *\n   * Updates a user.\n    *\n   * @example Update a user\n   * ```ts\n   * async function updateUserExample(username: Username) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateUser({\n   *     username,\n   *     name: 'Alice Jones',\n   *     email: 'alice.jones@example.com',\n   *   });\n   * }\n   * ```\n   * @operationId updateUser\n   * @tags User\n   */\n  updateUser(input: updateUserInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateUser>>;\n  updateUser(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateUser(this, arg, options);\n  }\n\n  /**\n   * Update user task\n   *\n   * Update a user task with the given key. Updates wait for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.\n   *\n    *\n   * @example Update a user task\n   * ```ts\n   * async function updateUserTaskExample(userTaskKey: UserTaskKey) {\n   *   const camunda = createCamundaClient();\n   * \n   *   await camunda.updateUserTask({\n   *     userTaskKey,\n   *     changeset: {\n   *       candidateUsers: ['alice', 'bob'],\n   *       dueDate: '2025-12-31T23:59:59Z',\n   *       priority: 80,\n   *     },\n   *   });\n   * }\n   * ```\n   * @operationId updateUserTask\n   * @tags User task\n   */\n  updateUserTask(input: updateUserTaskInput, options?: OperationOptions): CancelablePromise<_DataOf<typeof Sdk.updateUserTask>>;\n  updateUserTask(arg: any, options?: OperationOptions): CancelablePromise<any> {\n    return Ops.updateUserTask(this, arg, options);\n  }\n\n// === AUTO-GENERATED CAMUNDA METHODS END ===\n\n  /**\n   * Create a job worker that activates and processes jobs of the given type.\n   *\n   * Worker configuration fields inherit global defaults resolved via the\n   * unified configuration (environment variables or equivalent `CAMUNDA_WORKER_*`\n   * keys provided via `CamundaOptions.config`) when not explicitly set on the\n   * config object.\n   * @param cfg Worker configuration\n   * @example Create a job worker\n   * ```ts\n   * async function createJobWorkerExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const _worker = camunda.createJobWorker({\n   *     jobType: 'payment-processing',\n   *     jobTimeoutMs: 30000,\n   *     maxParallelJobs: 5,\n   *     jobHandler: async (job): Promise<JobActionReceipt> => {\n   *       console.log(`Processing job ${job.jobKey}`);\n   *       return job.complete({ processed: true });\n   *     },\n   *   });\n   * \n   *   // Workers run continuously until closed\n   *   // worker.close();\n   * }\n   * ```\n   * @example Job worker with error handling\n   * ```ts\n   * async function jobWorkerWithErrorHandlingExample() {\n   *   const camunda = createCamundaClient();\n   * \n   *   const worker = camunda.createJobWorker({\n   *     jobType: 'email-sending',\n   *     jobTimeoutMs: 60000,\n   *     maxParallelJobs: 10,\n   *     pollIntervalMs: 300,\n   *     jobHandler: async (job): Promise<JobActionReceipt> => {\n   *       try {\n   *         console.log(`Sending email for job ${job.jobKey}`);\n   *         return job.complete({ sent: true });\n   *       } catch (err) {\n   *         return job.fail({\n   *           errorMessage: String(err),\n   *           retries: (job.retries ?? 1) - 1,\n   *         });\n   *       }\n   *     },\n   *   });\n   * \n   *   void worker;\n   * }\n   * ```\n   */\n  createJobWorker<\n    In extends import('zod').ZodTypeAny = any,\n    Out extends import('zod').ZodTypeAny = any,\n    Headers extends import('zod').ZodTypeAny = any,\n  >(cfg: JobWorkerConfig<In, Out, Headers>): JobWorker {\n    const defaults = this._config.workerDefaults;\n    const merged = defaults\n      ? {\n          ...cfg,\n          jobTimeoutMs: cfg.jobTimeoutMs ?? defaults.jobTimeoutMs,\n          maxParallelJobs: cfg.maxParallelJobs ?? defaults.maxParallelJobs,\n          pollTimeoutMs: cfg.pollTimeoutMs ?? defaults.pollTimeoutMs,\n          workerName: cfg.workerName ?? defaults.workerName,\n          startupJitterMaxSeconds: cfg.startupJitterMaxSeconds ?? defaults.startupJitterMaxSeconds,\n        }\n      : cfg;\n    const worker = new JobWorker(this as any, merged as JobWorkerConfig);\n    this._workers.push(worker);\n    return worker;\n  }\n\n  /**\n   * Create a threaded job worker that runs handler logic in a pool of worker threads.\n   * The handler must be a separate module file that exports a default function with\n   * signature `(job, client) => Promise<JobActionReceipt>`.\n   *\n   * This keeps the main event loop free for polling and I/O, dramatically improving\n   * throughput for CPU-bound job handlers.\n   *\n   * Worker configuration fields inherit global defaults resolved via the\n   * unified configuration (environment variables or equivalent `CAMUNDA_WORKER_*`\n   * keys provided via `CamundaOptions.config`) when not explicitly set on the\n   * config object.\n   *\n   * @param cfg Threaded worker configuration\n   * @example Create a threaded job worker\n   * ```ts\n   * const worker = client.createThreadedJobWorker({\n   *   jobType: 'cpu-heavy-task',\n   *   handlerModule: './my-handler.js',\n   *   maxParallelJobs: 32,\n   *   jobTimeoutMs: 30000,\n   * })\n   * ```\n   */\n  createThreadedJobWorker<\n    In extends import('zod').ZodTypeAny = any,\n    Out extends import('zod').ZodTypeAny = any,\n    Headers extends import('zod').ZodTypeAny = any,\n  >(cfg: ThreadedJobWorkerConfig<In, Out, Headers>): ThreadedJobWorker {\n    const defaults = this._config.workerDefaults;\n    const merged = defaults\n      ? {\n          ...cfg,\n          jobTimeoutMs: cfg.jobTimeoutMs ?? defaults.jobTimeoutMs,\n          maxParallelJobs: cfg.maxParallelJobs ?? defaults.maxParallelJobs,\n          pollTimeoutMs: cfg.pollTimeoutMs ?? defaults.pollTimeoutMs,\n          workerName: cfg.workerName ?? defaults.workerName,\n          startupJitterMaxSeconds: cfg.startupJitterMaxSeconds ?? defaults.startupJitterMaxSeconds,\n        }\n      : cfg;\n    const pool = this._getOrCreateThreadPool(cfg.threadPoolSize);\n    const worker = new ThreadedJobWorker(this as any, pool, merged as ThreadedJobWorkerConfig);\n    this._workers.push(worker);\n    return worker;\n  }\n\n  /**\n   * Node-only convenience: deploy resources from local filesystem paths.\n   * @param resourceFilenames Absolute or relative file paths to BPMN/DMN/form/resource files.\n   * @param options Optional: tenantId.\n   * @returns ExtendedDeploymentResult\n   */\n  deployResourcesFromFiles(\n    resourceFilenames: string[],\n    options?: { tenantId?: string }\n  ): CancelablePromise<ExtendedDeploymentResult> {\n    return toCancelable(async (_signal) => {\n      if (!Array.isArray(resourceFilenames) || resourceFilenames.length === 0) {\n        throw new Error('resourceFilenames must be a non-empty string[]');\n      }\n      // Basic environment guard (avoid accidental browser usage)\n      if (!node || typeof process === 'undefined' || !process.versions?.node) {\n        throw new Error('deployResourcesFromFiles is only available in Node.js environments');\n      }\n      // Node built-ins come from the #platform seam (undefined in browser builds)\n      const {\n        fsPromises: { readFile },\n        path: pathMod,\n      } = node;\n      // Best-effort MIME inference\n      const mimeFor = (filename: string): string => {\n        const ext = filename.toLowerCase().split('.').pop() || '';\n        switch (ext) {\n          case 'bpmn':\n          case 'dmn':\n          case 'xml':\n            return 'application/xml';\n          case 'json':\n          case 'form':\n            return 'application/json';\n          default:\n            return 'application/octet-stream';\n        }\n      };\n      if (typeof File !== 'function') {\n        throw new Error(\n          'Global File constructor not available. Requires Node 18+ (fetch experimental) or Node 20+'\n        );\n      }\n      const files: File[] = [];\n      for (const p of resourceFilenames) {\n        if (typeof p !== 'string' || !p) throw new Error('Invalid resource filename encountered');\n        const data = await readFile(p);\n        const name = pathMod.basename(p);\n        files.push(new File([data as any], name, { type: mimeFor(name) }));\n      }\n      const payload: createDeploymentInput = {\n        resources: files,\n        ...(options?.tenantId ? { tenantId: options.tenantId } : {}),\n      } as any;\n      return this.createDeployment(payload);\n    });\n  }\n\n  /**\n   * Search for process variables and bind them to a Zod schema (the DTO).\n   *\n   * The schema's keys are the exact variable names to fetch; its shape drives validation. Only\n   * those declared variables are queried (via a `name $in [...]` filter), so memory stays bound\n   * by the DTO shape rather than the total number of variables on the instance. Results are\n   * paged internally until every declared variable is found or the result set is exhausted.\n   *\n   * Returns a {@link VariableMap} offering lenient access (`has` / `get`) and a strict\n   * `validate()` that parses the collected values against the schema — returning a fully-typed\n   * object or throwing a `ZodError` when a required variable is missing or malformed.\n   *\n   * @param schema A Zod object schema declaring the variables to fetch.\n   * @param options Query scope. `processInstanceKey` is required; `scopeKey` narrows to a single\n   *   element-instance scope, `tenantId` filters by tenant, and `pageSize` tunes the page limit.\n   *   `consistency` controls eventual-consistency tolerance for the underlying `searchVariables`\n   *   calls: it defaults to `{ waitUpToMs: 0 }` (no waiting), but a non-zero `waitUpToMs` makes the\n   *   paging calls poll until the data is consistent, avoiding intermittent missing variables /\n   *   `ZodError` on a freshly-updated instance.\n   * @throws {VariableScopeCollisionError} when a declared variable is found at more than one\n   *   scope and no `scopeKey` was provided to disambiguate.\n   * @throws {VariableDeserializationError} when a variable's value is not valid JSON.\n   *\n   * @example\n   * ```ts\n   * import { z } from 'zod';\n   * const OrderVariables = z.object({ orderId: z.string(), amount: z.number().optional() });\n   * const map = await client.searchVariablesAsDto(OrderVariables, { processInstanceKey });\n   * if (map.has('amount')) console.log(map.get('amount'));\n   * const order = map.validate(); // { orderId: string; amount?: number }\n   * ```\n   */\n  searchVariablesAsDto<TSchema extends AnyVariableSchema>(\n    schema: TSchema,\n    options: {\n      processInstanceKey: ProcessInstanceKey;\n      scopeKey?: ScopeKey;\n      tenantId?: TenantId;\n      pageSize?: number;\n      consistency?: { waitUpToMs: number; pollIntervalMs?: number };\n    }\n  ): CancelablePromise<VariableMap<TSchema>> {\n    return toCancelable(async (signal) => {\n      if (!options?.processInstanceKey) {\n        throw new Error('searchVariablesAsDto requires options.processInstanceKey');\n      }\n      const names = variableNamesFromSchema(schema);\n      const limit = options.pageSize && options.pageSize > 0 ? options.pageSize : 100;\n      const filter: VariableFilter = {\n        name: { $in: names },\n        processInstanceKey: options.processInstanceKey,\n      };\n      if (options.scopeKey) filter.scopeKey = options.scopeKey;\n      if (options.tenantId) filter.tenantId = options.tenantId;\n\n      return collectTypedVariables({\n        schema,\n        // A single scopeKey restricts results to one scope, so each declared name appears at most\n        // once and paging can stop as soon as all are found. Otherwise we page to exhaustion so a\n        // same-name/different-scope collision on a later page surfaces as a VariableScopeCollisionError.\n        singleScope: Boolean(options.scopeKey),\n        // Eventual-consistency waiting happens at the collection level: re-read until every declared\n        // variable is visible or the budget expires. The per-page search never waits — a paging read\n        // that legitimately returns 0 items must not block, and waiting on the first search alone\n        // settles on a partial result (its success condition is merely \"any matching variable\").\n        consistency: options.consistency,\n        fetchPage: createVariableSearchFetchPage({\n          filter,\n          limit,\n          signal,\n          search: (input) => this.searchVariables(input, { consistency: { waitUpToMs: 0 } }),\n        }),\n      });\n    });\n  }\n}\n\n/**\n * Public Camunda client type: the base class augmented with `.paginate(...)` on\n * every `search*` operation. The `.paginate` methods are installed at runtime by\n * the constructor (via `installSearchPagination`), so both construction paths —\n * the `createCamundaClient` factory *and* direct `new CamundaClient()` — yield a\n * value whose static type matches the runtime shape.\n *\n * This is expressed as a separate type + value pair rather than\n * declaration-merging an interface onto the class because\n * `SearchPaginationApi<CamundaClient>` is self-referential (it maps over\n * `keyof CamundaClient`), which TypeScript rejects as an interface `extends`\n * clause (\"recursively references itself as a base type\").\n */\nexport type CamundaClient = WithSearchPagination<CamundaClientBase>;\nexport const CamundaClient = CamundaClientBase as unknown as {\n  new (options?: CamundaOptions): CamundaClient;\n} & typeof CamundaClientBase;\n"],"mappings":"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","names":["node","node"]}