@camunda8/orchestration-cluster-api
    Preparing search index...

    Function createCamundaClientLoose

    • Create a client where all branded key types are widened to string. Use when integrating with external systems or when dynamic string keys are common and brand friction is unwanted. For maximum type safety prefer the strict createCamundaClient.

      Loose<T> rebuilds callable types and drops properties attached to them, which would strip the .paginate methods installed on every search* operation. We re-apply WithSearchPagination on top of the loosened client so loose clients keep .paginate in their static type (recomputed from the loosened search signatures), matching the runtime wrappers the constructor installs.

      Parameters

      Returns WithSearchPagination<
          {
              clock: {
                  deadline(
                      ...a: [ms: number],
                  ): { dispose: (...a: []) => void; signal: {} };
                  now(...a: []): number;
                  sleep(...a: [ms: number, signal?: {}]): Promise<void>;
              };
              config: {
                  __raw: { [key: string]: string
                  | undefined };
                  auth: {
                      basic?: { password?: string; username?: string };
                      strategy: AuthStrategy;
                  };
                  backpressure: {
                      decayQuietMs: number;
                      enabled: boolean;
                      floor: number;
                      healthyRecoveryMultiplier: number;
                      initialMax: number;
                      maxWaiters: number;
                      observeOnly: boolean;
                      profile: string;
                      recoveryIntervalMs: number;
                      recoveryStep: number;
                      severeFactor: number;
                      severeThreshold: number;
                      softFactor: number;
                      unlimitedAfterHealthyMs: number;
                  };
                  defaultTenantId: string;
                  eventual?: { pollDefaultMs: number };
                  httpRetry: {
                      baseDelayMs: number;
                      maxAttempts: number;
                      maxDelayMs: number;
                  };
                  logLevel: "trace"
                  | "error"
                  | "silent"
                  | "warn"
                  | "info"
                  | "debug";
                  mtls?: {
                      ca?: string;
                      caPath?: string;
                      cert?: string;
                      certPath?: string;
                      key?: string;
                      keyPassphrase?: string;
                      keyPath?: string;
                  };
                  oauth: {
                      cacheDir?: string;
                      clientId?: string;
                      clientSecret?: string;
                      grantType: string;
                      oauthUrl: string;
                      retry: { baseDelayMs: number; max: number };
                      scope?: string;
                      timeoutMs: number;
                  };
                  restAddress: string;
                  restAddressExact: boolean;
                  supportLog?: { enabled: boolean; filePath: string };
                  telemetry?: { correlation: boolean; log: boolean };
                  tokenAudience: string;
                  validation: { raw: string; req: ValidationMode; res: ValidationMode };
                  workerDefaults?: {
                      jobTimeoutMs?: number;
                      maxParallelJobs?: number;
                      pollTimeoutMs?: number;
                      startupJitterMaxSeconds?: number;
                      workerName?: string;
                  };
              };
              random: { next(...a: []): number };
              _getSupportLogger(
                  ...a: [],
              ): {
                  log(
                      ...a: [
                          message: string
                          | number
                          | boolean
                          | object,
                          addTimestamp?: boolean,
                      ],
                  ): void;
              };
              _invokeWithRetry(
                  ...a: [
                      op: (...a: []) => Promise<unknown>,
                      opts: {
                          classify?: (
                              ...a: [e: any],
                          ) => { reason: string; retryable: boolean };
                          exempt?: boolean;
                          opId: string;
                          retryOverride?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): Promise<unknown>;
              activateAdHocSubProcessActivities(
                  ...a: [
                      input: {
                          adHocSubProcessInstanceKey: string;
                          cancelRemainingInstances?: boolean;
                          elements: { elementId: string; variables?: { [key: string]: unknown } }[];
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              activateJobs(
                  ...a: [
                      input: {
                          fetchVariable?: string[];
                          maxJobsToActivate: number;
                          requestTimeout?: number;
                          tenantFilter?: TenantFilterEnum;
                          tenantIds?: string[];
                          timeout: number;
                          type: string;
                          withLease?: boolean
                          | null;
                          worker?: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      jobs: {
                          acknowledged?: boolean;
                          businessId: | { __brand: "BusinessId"; readonly [key: number]: string }
                          | null;
                          clock: {
                              now(...a: []): number;
                              sleep(...a: [ms: number, signal?: {}]): Promise<void>;
                          };
                          customHeaders: { [key: string]: unknown };
                          deadline: number;
                          elementId: string;
                          elementInstanceKey: string;
                          jobKey: string;
                          jobLeaseToken:
                              | { __brand: "JobLeaseToken"; readonly [key: number]: string }
                              | null;
                          kind: JobKindEnum;
                          listenerEventType: JobListenerEventTypeEnum;
                          log: {
                              code(
                                  ...a: [level: LogLevel, code: string, msg: string, data?: any],
                              ): void;
                              debug(...a: any[]): void;
                              error(...a: any[]): void;
                              info(...a: any[]): void;
                              level(...a: []): LogLevel;
                              scope(
                                  ...a: [child: string],
                              ): { level: () => LogLevel; setLevel: (level: LogLevel) => void; setTransport: (t?: ((e: { level: LogLevel; scope: string; ts: number; args: any[]; code?: string | undefined; data?: any; }) => void) | undefined) => void; ... 7 more ...; code: (level: LogLevel, code: string, msg: string, data?: any) => void; };
                              setLevel(...a: [level: LogLevel]): void;
                              setTransport(...a: [t?: (...a: [e: ...]) => void]): void;
                              silly(...a: any[]): void;
                              trace(...a: any[]): void;
                              warn(...a: any[]): void;
                          };
                          modifyJobTimeout: (...a: [{ newTimeoutMs: number }]) => Promise<void>;
                          modifyRetries: (...a: [{ retries: number }]) => Promise<void>;
                          physicalTenantId: string;
                          priority: number;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processDefinitionVersion: number;
                          processInstanceKey: string;
                          retries: number;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          tags: string[];
                          tenantId: string;
                          type: string;
                          userTask:
                              | {
                                  action: string;
                                  assignee: string
                                  | null;
                                  candidateGroups: string[];
                                  candidateUsers: string[];
                                  changedAttributes: string[];
                                  dueDate: string | null;
                                  followUpDate: string | null;
                                  formKey:
                                      | { __brand: "FormKey"; readonly [key: number]: string }
                                      | null;
                                  priority: number | null;
                                  userTaskKey:
                                      | { __brand: "UserTaskKey"; readonly [key: number]: string }
                                      | null;
                              }
                              | null;
                          variables: { [key: string]: unknown };
                          worker: string;
                          cancelWorkflow(...a: []): Promise<"JOB_ACTION_RECEIPT">;
                          complete(
                              ...a: [
                                  variables?: { [key: string]: any },
                                  result?:
                                      | {
                                          corrections?: | {
                                              assignee?: ...;
                                              candidateGroups?: ...;
                                              candidateUsers?: ...;
                                              dueDate?: ...;
                                              followUpDate?: ...;
                                              priority?: ...;
                                          }
                                          | null;
                                          denied?: boolean
                                          | null;
                                          deniedReason?: string | null;
                                          type: "userTask";
                                      }
                                      | {
                                          activateElements?: (...)[];
                                          isCancelRemainingInstances?: boolean;
                                          isCompletionConditionFulfilled?: boolean;
                                          type: "adHocSubProcess";
                                      },
                              ],
                          ): Promise<"JOB_ACTION_RECEIPT">;
                          error(
                              ...a: [
                                  error: {
                                      errorCode: string;
                                      errorMessage?: string
                                      | null;
                                      jobLeaseToken?:
                                          | { __brand: "JobLeaseToken"; readonly [key: number]: string }
                                          | null;
                                      variables?: { [key: string]: unknown } | null;
                                  },
                              ],
                          ): Promise<"JOB_ACTION_RECEIPT">;
                          fail(...a: [body: any]): Promise<"JOB_ACTION_RECEIPT">;
                          ignore(...a: []): Promise<"JOB_ACTION_RECEIPT">;
                      }[];
                  },
              >;
              addClock(
                  ...a: [
                      input: { offset: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ timestamp: string }>;
              assignClientToGroup(
                  ...a: [
                      input: { clientId: string; groupId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignClientToTenant(
                  ...a: [
                      input: { clientId: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignGroupToTenant(
                  ...a: [
                      input: { groupId: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignMappingRuleToGroup(
                  ...a: [
                      input: { groupId: string; mappingRuleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignMappingRuleToTenant(
                  ...a: [
                      input: { mappingRuleId: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignProcessInstanceBusinessId(
                  ...a: [
                      input: { businessId: string; processInstanceKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignRoleToClient(
                  ...a: [
                      input: { clientId: string; roleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignRoleToGroup(
                  ...a: [
                      input: { groupId: string; roleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignRoleToMappingRule(
                  ...a: [
                      input: { mappingRuleId: string; roleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignRoleToTenant(
                  ...a: [
                      input: { roleId: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignRoleToUser(
                  ...a: [
                      input: { roleId: string; username: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignUserTask(
                  ...a: [
                      input: {
                          action?: string
                          | null;
                          allowOverride?: boolean | null;
                          assignee: string;
                          userTaskKey: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignUserToGroup(
                  ...a: [
                      input: { groupId: string; username: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              assignUserToTenant(
                  ...a: [
                      input: { tenantId: string; username: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              broadcastSignal(
                  ...a: [
                      input: {
                          signalName: string;
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          variables?: { [key: string]: unknown };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ signalKey: string; tenantId: string }>;
              cancelBatchOperation(
                  ...a: [
                      input: { batchOperationKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              cancelClusterRebalance(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ wasRunning: boolean }>;
              cancelProcessInstance(
                  ...a: [
                      input: { operationReference?: number; processInstanceKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              cancelProcessInstancesBatchOperation(
                  ...a: [
                      input: {
                          filter: {
                              $or?: {
                                  batchOperationId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  batchOperationKey?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementInstanceState?: | ElementInstanceStateEnum
                                  | {
                                      $eq?: ElementInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ElementInstanceStateEnum | undefined;
                                  };
                                  endDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  errorMessage?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  hasElementInstanceIncident?: boolean;
                                  hasIncident?: boolean;
                                  hasRetriesLeft?: boolean;
                                  incidentErrorHashCode?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  parentElementInstanceKey?: | {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  parentProcessInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionKey?: | {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionName?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionVersion?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  processDefinitionVersionTag?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  startDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  state?: | ProcessInstanceStateEnum
                                  | {
                                      $eq?: ProcessInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ProcessInstanceStateEnum | undefined;
                                  };
                                  suspendedDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  tags?: string[];
                                  tenantId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  variables?: { name: ...; value: ... }[];
                              }[];
                              batchOperationId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceState?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasElementInstanceIncident?: boolean;
                              hasIncident?: boolean;
                              hasRetriesLeft?: boolean;
                              incidentErrorHashCode?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              parentElementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              parentProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ProcessInstanceStateEnum
                              | {
                                  $eq?: ProcessInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ProcessInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ProcessInstanceStateEnum | undefined;
                              };
                              suspendedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              variables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                              }[];
                          };
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              changeClusterMode(
                  ...a: [
                      input: { dryRun?: boolean; mode: "PROCESSING"
                      | "RECOVERING" },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      changeId: string;
                      plannedChanges: {
                          operations: { mode: string
                          | null; operation: string }[];
                          physicalTenantId: string | null;
                      }[];
                  },
              >;
              changeClusterModeAsClusterAdmin(
                  ...a: [
                      input: {
                          dryRun?: boolean;
                          mode: "PROCESSING"
                          | "RECOVERING";
                          physicalTenantId?: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      changeId: string;
                      plannedChanges: {
                          operations: { mode: string
                          | null; operation: string }[];
                          physicalTenantId: string | null;
                      }[];
                  },
              >;
              clearAuthCache(...a: [opts?: { disk?: boolean; memory?: boolean }]): void;
              completeJob(
                  ...a: [
                      input: {
                          businessId?: | {
                              __brand: "BusinessId";
                              readonly [key: number]: string;
                          }
                          | null;
                          jobKey: string;
                          jobLeaseToken?: | {
                              __brand: "JobLeaseToken";
                              readonly [key: number]: string;
                          }
                          | null;
                          result?: | {
                              corrections?: | {
                                  assignee?: string
                                  | null;
                                  candidateGroups?: string[] | null;
                                  candidateUsers?: string[] | null;
                                  dueDate?: ClearableDateTime;
                                  followUpDate?: ClearableDateTime;
                                  priority?: number | null;
                              }
                              | null;
                              denied?: boolean
                              | null;
                              deniedReason?: string | null;
                              type: "userTask";
                          }
                          | {
                              activateElements?: {
                                  elementId?: { __brand: ...; readonly [key: ...]: ... };
                                  variables?: { [key: ...]: ... } | null;
                              }[];
                              isCancelRemainingInstances?: boolean;
                              isCompletionConditionFulfilled?: boolean;
                              type: "adHocSubProcess";
                          };
                          variables?: { [key: string]: unknown }
                          | null;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              completeUserTask(
                  ...a: [
                      input: {
                          action?: string
                          | null;
                          userTaskKey: string;
                          variables?: { [key: string]: unknown } | null;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              configure(
                  ...a: [
                      next: {
                          __camundaComponent?: "CamundaCore"
                          | "CamundaClient";
                          clock?: {
                              deadline(
                                  ...a: [ms: number],
                              ): { dispose: (...a: []) => void; signal: {} };
                              now(...a: []): number;
                              sleep(...a: [ms: number, signal?: {}]): Promise<void>;
                          };
                          config?: {
                              CAMUNDA_AUTH_STRATEGY?: "OAUTH"
                              | "NONE"
                              | "BASIC";
                              CAMUNDA_BASIC_AUTH_PASSWORD?: string;
                              CAMUNDA_BASIC_AUTH_USERNAME?: string;
                              CAMUNDA_CLIENT_ID?: string;
                              CAMUNDA_CLIENT_SECRET?: string;
                              CAMUNDA_DEFAULT_TENANT_ID?: string;
                              CAMUNDA_MTLS_CA?: string;
                              CAMUNDA_MTLS_CA_PATH?: string;
                              CAMUNDA_MTLS_CERT?: string;
                              CAMUNDA_MTLS_CERT_PATH?: string;
                              CAMUNDA_MTLS_KEY?: string;
                              CAMUNDA_MTLS_KEY_PASSPHRASE?: string;
                              CAMUNDA_MTLS_KEY_PATH?: string;
                              CAMUNDA_OAUTH_CACHE_DIR?: string;
                              CAMUNDA_OAUTH_GRANT_TYPE?: string;
                              CAMUNDA_OAUTH_RETRY_BASE_DELAY_MS?: number;
                              CAMUNDA_OAUTH_RETRY_MAX?: number;
                              CAMUNDA_OAUTH_SCOPE?: string;
                              CAMUNDA_OAUTH_TIMEOUT_MS?: number;
                              CAMUNDA_OAUTH_URL?: string;
                              CAMUNDA_REST_ADDRESS?: string;
                              CAMUNDA_REST_ADDRESS_EXACT?: boolean;
                              CAMUNDA_SDK_BACKPRESSURE_DECAY_QUIET_MS?: number;
                              CAMUNDA_SDK_BACKPRESSURE_FLOOR?: number;
                              CAMUNDA_SDK_BACKPRESSURE_HEALTHY_RECOVERY_MULTIPLIER?: number;
                              CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX?: number;
                              CAMUNDA_SDK_BACKPRESSURE_MAX_WAITERS?: number;
                              CAMUNDA_SDK_BACKPRESSURE_PROFILE?:
                                  | "BALANCED"
                                  | "CONSERVATIVE"
                                  | "AGGRESSIVE"
                                  | "LEGACY";
                              CAMUNDA_SDK_BACKPRESSURE_RECOVERY_INTERVAL_MS?: number;
                              CAMUNDA_SDK_BACKPRESSURE_RECOVERY_STEP?: number;
                              CAMUNDA_SDK_BACKPRESSURE_SEVERE_FACTOR?: number;
                              CAMUNDA_SDK_BACKPRESSURE_SEVERE_THRESHOLD?: number;
                              CAMUNDA_SDK_BACKPRESSURE_SOFT_FACTOR?: number;
                              CAMUNDA_SDK_BACKPRESSURE_UNLIMITED_AFTER_HEALTHY_MS?: number;
                              CAMUNDA_SDK_EVENTUAL_POLL_DEFAULT_MS?: number;
                              CAMUNDA_SDK_HTTP_RETRY_BASE_DELAY_MS?: number;
                              CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS?: number;
                              CAMUNDA_SDK_HTTP_RETRY_MAX_DELAY_MS?: number;
                              CAMUNDA_SDK_LOG_LEVEL?: | "trace"
                              | "error"
                              | "silent"
                              | "warn"
                              | "info"
                              | "debug"
                              | "silly";
                              CAMUNDA_SDK_TELEMETRY_CORRELATION?: boolean;
                              CAMUNDA_SDK_TELEMETRY_LOG?: boolean;
                              CAMUNDA_SDK_VALIDATION?: string;
                              CAMUNDA_SUPPORT_LOG_ENABLED?: boolean;
                              CAMUNDA_SUPPORT_LOG_FILE_PATH?: string;
                              CAMUNDA_SUPPORT_LOGGER?: boolean;
                              CAMUNDA_TOKEN_AUDIENCE?: string;
                              CAMUNDA_WORKER_MAX_CONCURRENT_JOBS?: number;
                              CAMUNDA_WORKER_NAME?: string;
                              CAMUNDA_WORKER_REQUEST_TIMEOUT?: number;
                              CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS?: number;
                              CAMUNDA_WORKER_TIMEOUT?: number;
                          };
                          env?: { [key: string]: string
                          | undefined };
                          fetch?: (...a: [input: string | {} | {}, init?: {}]) => Promise<{}>;
                          log?: {
                              level?: LogLevel;
                              transport?: (
                                  ...a: [
                                      e: {
                                          args: (...)[];
                                          code?: (...) | (...);
                                          data?: any;
                                          level: LogLevel;
                                          scope: string;
                                          ts: number;
                                      },
                                  ],
                              ) => void;
                          };
                          random?: { next(...a: []): number };
                          supportLogger?: {
                              log(
                                  ...a: [
                                      message: string
                                      | number
                                      | boolean
                                      | object,
                                      addTimestamp?: boolean,
                                  ],
                              ): void;
                          };
                          telemetry?: {
                              correlation?: boolean;
                              hooks?: {
                                  afterResponse?: (...a: [e: ...]) => void;
                                  authError?: (...a: [e: ...]) => void;
                                  authStart?: (...a: [e: ...]) => void;
                                  authSuccess?: (...a: [e: ...]) => void;
                                  beforeRequest?: (...a: [e: ...]) => void;
                                  requestError?: (...a: [e: ...]) => void;
                                  retry?: (...a: [e: ...]) => void;
                              };
                              mirrorToLog?: boolean;
                          };
                          throwOnError?: boolean;
                      },
                  ],
              ): void;
              correlateMessage(
                  ...a: [
                      input: {
                          businessId?: {
                              __brand: "BusinessId";
                              readonly [key: number]: string;
                          };
                          correlationKey?: string;
                          name: string;
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          variables?: { [key: string]: unknown };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { messageKey: string; processInstanceKey: string; tenantId: string },
              >;
              createAdminUser(
                  ...a: [
                      input: {
                          email?: string;
                          name?: string;
                          password: string;
                          username: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { email: string
                  | null; name: string | null; username: string },
              >;
              createAgentInstance(
                  ...a: [
                      input: {
                          elementInstanceKey: string;
                          history: {
                              content: (
                                  | { contentType: "TEXT"; text: string }
                                  | {
                                      contentType: "DOCUMENT";
                                      documentReference: {
                                          "camunda.document.type": "camunda";
                                          contentHash: (...) | (...);
                                          documentId: string;
                                          metadata: {
                                              contentType: ...;
                                              customProperties: ...;
                                              expiresAt: ...;
                                              fileName: ...;
                                              processDefinitionId: ...;
                                              processInstanceKey: ...;
                                              size: ...;
                                          };
                                          storeId: string;
                                      };
                                  }
                                  | { contentType: "OBJECT"; object: unknown }
                              )[];
                              historyItemId: string;
                              limits?: {
                                  maxModelCalls: number;
                                  maxTokens: number;
                                  maxToolCalls: number;
                              };
                              loopIteration: number;
                              metrics?: | {
                                  cacheCreationTokenCount?: number
                                  | null;
                                  cacheReadTokenCount?: number | null;
                                  durationMs?: number | null;
                                  inputTokens?: number | null;
                                  outputTokens?: number | null;
                                  reasoningTokenCount?: number | null;
                              }
                              | null;
                              model?: string;
                              producedAt: string;
                              provider?: string;
                              role: AgentInstanceHistoryRoleEnum;
                              systemPrompt?: | (
                                  | { contentType: "TEXT"; text: string }
                                  | {
                                      contentType: "DOCUMENT";
                                      documentReference: {
                                          "camunda.document.type": ...;
                                          contentHash: ...;
                                          documentId: ...;
                                          metadata: ...;
                                          storeId: ...;
                                      };
                                  }
                                  | { contentType: "OBJECT"; object: unknown }
                              )[]
                              | null;
                              toolCalls?:
                                  | {
                                      arguments: { [key: ...]: ... }
                                      | null;
                                      elementId: { __brand: ...; readonly [key: ...]: ... } | null;
                                      toolCallId: string;
                                      toolName: string;
                                  }[]
                                  | null;
                              tools?: | {
                                  description: string
                                  | null;
                                  elementId: { __brand: ...; readonly [key: ...]: ... } | null;
                                  name: string;
                              }[]
                              | null;
                          }[];
                          jobKey: string;
                          jobLeaseToken: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      agentInstanceKey: string;
                      createdHistory: {
                          historyItemId: string;
                          historyItemKey: string;
                          isDuplicate: boolean;
                      }[];
                  },
              >;
              createAuthorization(
                  ...a: [
                      input: | {
                          ownerId: string;
                          ownerType: OwnerTypeEnum;
                          permissionTypes: PermissionTypeEnum[];
                          resourceId: string;
                          resourceType: ResourceTypeEnum;
                      }
                      | {
                          ownerId: string;
                          ownerType: OwnerTypeEnum;
                          permissionTypes: PermissionTypeEnum[];
                          resourcePropertyName: string;
                          resourceType: ResourceTypeEnum;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ authorizationKey: string }>;
              createDeployment(
                  ...a: [
                      input: {
                          resources: {}[];
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      decisionRequirements: {
                          decisionRequirementsId: string;
                          decisionRequirementsKey: string;
                          decisionRequirementsName: string;
                          resourceName: string;
                          tenantId: string;
                          version: number;
                      }[];
                      decisions: {
                          decisionDefinitionId: string;
                          decisionDefinitionKey: string;
                          decisionRequirementsId: string;
                          decisionRequirementsKey: string;
                          name: string;
                          tenantId: string;
                          version: number;
                      }[];
                      deploymentKey: string;
                      deployments: {
                          decisionDefinition: | {
                              decisionDefinitionId: string;
                              decisionDefinitionKey: string;
                              decisionRequirementsId: string;
                              decisionRequirementsKey: string;
                              name: string;
                              tenantId: string;
                              version: number;
                          }
                          | null;
                          decisionRequirements: | {
                              decisionRequirementsId: string;
                              decisionRequirementsKey: string;
                              decisionRequirementsName: string;
                              resourceName: string;
                              tenantId: string;
                              version: number;
                          }
                          | null;
                          form: | {
                              formId: string;
                              formKey: string;
                              resourceName: string;
                              tenantId: string;
                              version: number;
                          }
                          | null;
                          processDefinition: | {
                              processDefinitionId: string;
                              processDefinitionKey: string;
                              processDefinitionVersion: number;
                              resourceName: string;
                              tenantId: string;
                          }
                          | null;
                          resource: | {
                              resourceId: string;
                              resourceKey: string;
                              resourceName: string;
                              tenantId: string;
                              version: number;
                          }
                          | null;
                      }[];
                      forms: {
                          formId: string;
                          formKey: string;
                          resourceName: string;
                          tenantId: string;
                          version: number;
                      }[];
                      processes: {
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processDefinitionVersion: number;
                          resourceName: string;
                          tenantId: string;
                      }[];
                      resources: {
                          resourceId: string;
                          resourceKey: string;
                          resourceName: string;
                          tenantId: string;
                          version: number;
                      }[];
                      tenantId: string;
                  },
              >;
              createDocument(
                  ...a: [
                      input: {
                          documentId?: {
                              __brand: "DocumentId";
                              readonly [key: number]: string;
                          };
                          file: {}
                          | {};
                          metadata?: {
                              contentType?: string;
                              customProperties?: { [key: string]: unknown };
                              expiresAt?: string;
                              fileName?: string;
                              processDefinitionId?: {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              };
                              processInstanceKey?: {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              };
                              size?: number;
                          };
                          storeId?: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      "camunda.document.type": "camunda";
                      contentHash: string
                      | null;
                      documentId: string;
                      metadata: {
                          contentType: string;
                          customProperties: { [key: string]: unknown };
                          expiresAt: string | null;
                          fileName: string;
                          processDefinitionId:
                              | {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              }
                              | null;
                          processInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          size: number;
                      };
                      storeId: string;
                  },
              >;
              createDocumentLink(
                  ...a: [
                      input: {
                          contentHash?: string;
                          documentId: string;
                          storeId?: string;
                          timeToLive?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ expiresAt: string; url: string }>;
              createDocuments(
                  ...a: [
                      input: {
                          files: ({} | {})[];
                          metadataList?: {
                              contentType?: string;
                              customProperties?: { [key: string]: unknown };
                              expiresAt?: string;
                              fileName?: string;
                              processDefinitionId?: {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              };
                              processInstanceKey?: {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              };
                              size?: number;
                          }[];
                          storeId?: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      createdDocuments: {
                          "camunda.document.type": "camunda";
                          contentHash: string
                          | null;
                          documentId: string;
                          metadata: {
                              contentType: string;
                              customProperties: { [key: string]: unknown };
                              expiresAt: string | null;
                              fileName: string;
                              processDefinitionId:
                                  | {
                                      __brand: "ProcessDefinitionId";
                                      readonly [key: number]: string;
                                  }
                                  | null;
                              processInstanceKey: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | null;
                              size: number;
                          };
                          storeId: string;
                      }[];
                      failedDocuments: {
                          detail: string;
                          fileName: string;
                          status: number;
                          title: string;
                      }[];
                  },
              >;
              createElementInstanceVariables(
                  ...a: [
                      input: {
                          elementInstanceKey: string;
                          local?: boolean;
                          operationReference?: number;
                          variables: { [key: string]: unknown };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              createGlobalClusterVariable(
                  ...a: [
                      input: {
                          kind?: ClusterVariableKindEnum;
                          metadata?: { [key: string]: string
                          | number };
                          name: string;
                          value: unknown;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      kind: ClusterVariableKindEnum;
                      metadata: { [key: string]: string
                      | number };
                      name: string;
                      scope: ClusterVariableScopeEnum;
                      tenantId: string | null;
                      value: string;
                  },
              >;
              createGlobalTaskListener(
                  ...a: [
                      input: {
                          afterNonGlobal?: boolean;
                          eventTypes: GlobalTaskListenerEventTypeEnum[];
                          id: string;
                          priority?: number;
                          retries?: number;
                          type?: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      afterNonGlobal?: boolean;
                      eventTypes: GlobalTaskListenerEventTypeEnum[];
                      id: string;
                      priority?: number;
                      retries?: number;
                      source: GlobalListenerSourceEnum;
                      type?: string;
                  },
              >;
              createGroup(
                  ...a: [
                      input: { description?: string; groupId: string; name: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { description: string
                  | null; groupId: string; name: string },
              >;
              createJobWorker(
                  ...a: [
                      cfg: {
                          autoStart?: boolean;
                          customHeadersSchema?: {};
                          fetchVariables?: string[];
                          inputSchema?: {};
                          jobHandler: (
                              ...a: [
                                  job: {
                                      acknowledged?: boolean;
                                      businessId: | {
                                          __brand: "BusinessId";
                                          readonly [key: number]: string;
                                      }
                                      | null;
                                      clock: {
                                          now(...a: []): number;
                                          sleep(...a: [ms: number, signal?: {}]): Promise<void>;
                                      };
                                      customHeaders: { [key: string]: unknown };
                                      deadline: number;
                                      elementId: string;
                                      elementInstanceKey: string;
                                      jobKey: string;
                                      jobLeaseToken:
                                          | { __brand: "JobLeaseToken"; readonly [key: number]: string }
                                          | null;
                                      kind: JobKindEnum;
                                      listenerEventType: JobListenerEventTypeEnum;
                                      log: {
                                          code(
                                              ...a: [level: LogLevel, code: string, msg: string, data?: any],
                                          ): void;
                                          debug(...a: any[]): void;
                                          error(...a: any[]): void;
                                          info(...a: any[]): void;
                                          level(...a: []): LogLevel;
                                          scope(
                                              ...a: [child: string],
                                          ): { level: () => LogLevel; setLevel: (level: LogLevel) => void; setTransport: (t?: ((e: { level: LogLevel; scope: string; ts: number; args: any[]; code?: string | undefined; data?: any; }) => void) | undefined) => void; ... 7 more ...; code: (level: LogLevel, code: string, msg: string, data?: any) => void; };
                                          setLevel(...a: [level: LogLevel]): void;
                                          setTransport(...a: [t?: (...a: ...) => ...]): void;
                                          silly(...a: any[]): void;
                                          trace(...a: any[]): void;
                                          warn(...a: any[]): void;
                                      };
                                      modifyJobTimeout: (
                                          ...a: [{ newTimeoutMs: number }],
                                      ) => Promise<void>;
                                      modifyRetries: (...a: [{ retries: number }]) => Promise<void>;
                                      physicalTenantId: string;
                                      priority: number;
                                      processDefinitionId: string;
                                      processDefinitionKey: string;
                                      processDefinitionVersion: number;
                                      processInstanceKey: string;
                                      retries: number;
                                      rootProcessInstanceKey:
                                          | {
                                              __brand: "ProcessInstanceKey";
                                              readonly [key: number]: string;
                                          }
                                          | null;
                                      tags: string[];
                                      tenantId: string;
                                      type: string;
                                      userTask: | {
                                          action: string;
                                          assignee: string
                                          | null;
                                          candidateGroups: string[];
                                          candidateUsers: string[];
                                          changedAttributes: string[];
                                          dueDate: string | null;
                                          followUpDate: string | null;
                                          formKey: { __brand: ...; readonly [key: ...]: ... } | null;
                                          priority: number | null;
                                          userTaskKey: { __brand: ...; readonly [key: ...]: ... } | null;
                                      }
                                      | null;
                                      variables: { [key: string]: unknown };
                                      worker: string;
                                      cancelWorkflow(...a: []): Promise<"JOB_ACTION_RECEIPT">;
                                      complete(
                                          ...a: [
                                              variables?: { [key: string]: any },
                                              result?:
                                                  | {
                                                      corrections?: (...)
                                                      | (...)
                                                      | (...);
                                                      denied?: (...) | (...) | (...) | (...);
                                                      deniedReason?: (...) | (...) | (...);
                                                      type: "userTask";
                                                  }
                                                  | {
                                                      activateElements?: (...)
                                                      | (...);
                                                      isCancelRemainingInstances?: (...) | (...) | (...);
                                                      isCompletionConditionFulfilled?: (...) | (...) | (...);
                                                      type: "adHocSubProcess";
                                                  },
                                          ],
                                      ): Promise<"JOB_ACTION_RECEIPT">;
                                      error(
                                          ...a: [
                                              error: {
                                                  errorCode: string;
                                                  errorMessage?: string
                                                  | null;
                                                  jobLeaseToken?: { __brand: ...; readonly [key: ...]: ... } | null;
                                                  variables?: { [key: ...]: ... } | null;
                                              },
                                          ],
                                      ): Promise<"JOB_ACTION_RECEIPT">;
                                      fail(...a: [body: any]): Promise<"JOB_ACTION_RECEIPT">;
                                      ignore(...a: []): Promise<"JOB_ACTION_RECEIPT">;
                                  },
                              ],
                          ) => "JOB_ACTION_RECEIPT"
                          | Promise<"JOB_ACTION_RECEIPT">;
                          jobTimeoutMs?: number;
                          jobType: string;
                          maxBackoffTimeMs?: number;
                          maxParallelJobs?: number;
                          outputSchema?: {};
                          pollBackoffMaxMs?: number;
                          pollBackoffMinMs?: number;
                          pollIntervalMs?: number;
                          pollTimeoutMs?: number;
                          startupJitterMaxSeconds?: number;
                          validateSchemas?: boolean;
                          withLease?: boolean;
                          workerName?: string;
                      },
                  ],
              ): {
                  activeJobs: number;
                  name: string;
                  stopped: boolean;
                  start(...a: []): void;
                  stop(...a: []): void;
                  stopGracefully(
                      ...a: [opts?: { checkIntervalMs?: number; waitUpToMs?: number }],
                  ): Promise<{ remainingJobs: number; timedOut: boolean }>;
              };
              createMappingRule(
                  ...a: [
                      input: {
                          claimName: string;
                          claimValue: string;
                          mappingRuleId: string;
                          name: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      claimName: string;
                      claimValue: string;
                      mappingRuleId: string;
                      name: string;
                  },
              >;
              createProcessInstance(
                  ...a: [
                      input: | {
                          awaitCompletion?: boolean;
                          businessId?: { __brand: "BusinessId"; readonly [key: number]: string };
                          fetchVariables?: string[];
                          operationReference?: number;
                          processDefinitionKey: string;
                          processDefinitionVersion?: number;
                          requestTimeout?: number;
                          runtimeInstructions?: {
                              afterElementId: string;
                              type: "TERMINATE_PROCESS_INSTANCE";
                          }[];
                          startInstructions?: { elementId: string }[];
                          tags?: string[];
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          variables?: { [key: string]: unknown };
                      }
                      | {
                          awaitCompletion?: boolean;
                          businessId?: { __brand: "BusinessId"; readonly [key: number]: string };
                          fetchVariables?: string[];
                          operationReference?: number;
                          processDefinitionId: string;
                          processDefinitionVersion?: number;
                          requestTimeout?: number;
                          runtimeInstructions?: {
                              afterElementId: string;
                              type: "TERMINATE_PROCESS_INSTANCE";
                          }[];
                          startInstructions?: { elementId: string }[];
                          tags?: string[];
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          variables?: { [key: string]: unknown };
                      }
                      | {
                          awaitCompletion?: boolean;
                          businessId?: { __brand: "BusinessId"; readonly [key: number]: string };
                          fetchVariables?: string[];
                          operationReference?: number;
                          processDefinitionId: string;
                          processDefinitionVersionTag: string;
                          requestTimeout?: number;
                          runtimeInstructions?: {
                              afterElementId: string;
                              type: "TERMINATE_PROCESS_INSTANCE";
                          }[];
                          startInstructions?: { elementId: string }[];
                          tags?: string[];
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          variables?: { [key: string]: unknown };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      businessId: | {
                          __brand: "BusinessId";
                          readonly [key: number]: string;
                      }
                      | null;
                      processDefinitionId: string;
                      processDefinitionKey: string;
                      processDefinitionVersion: number;
                      processInstanceKey: string;
                      tags: string[];
                      tenantId: string;
                      variables: { [key: string]: unknown };
                  },
              >;
              createRole(
                  ...a: [
                      input: { description?: string; name: string; roleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { description: string
                  | null; name: string; roleId: string },
              >;
              createTenant(
                  ...a: [
                      input: { description?: string; name: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { description: string
                  | null; name: string; tenantId: string },
              >;
              createTenantClusterVariable(
                  ...a: [
                      input: {
                          kind?: ClusterVariableKindEnum;
                          metadata?: { [key: string]: string
                          | number };
                          name: string;
                          tenantId: string;
                          value: unknown;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      kind: ClusterVariableKindEnum;
                      metadata: { [key: string]: string
                      | number };
                      name: string;
                      scope: ClusterVariableScopeEnum;
                      tenantId: string | null;
                      value: string;
                  },
              >;
              createThreadedJobWorker(
                  ...a: [
                      cfg: {
                          autoStart?: boolean;
                          customHeadersSchema?: {};
                          fetchVariables?: string[];
                          handlerModule: string;
                          inputSchema?: {};
                          jobTimeoutMs?: number;
                          jobType: string;
                          maxParallelJobs?: number;
                          outputSchema?: {};
                          pollBackoffMaxMs?: number;
                          pollBackoffMinMs?: number;
                          pollIntervalMs?: number;
                          pollTimeoutMs?: number;
                          startupJitterMaxSeconds?: number;
                          threadPoolSize?: number;
                          validateSchemas?: boolean;
                          withLease?: boolean;
                          workerName?: string;
                      },
                  ],
              ): {
                  activeJobs: number;
                  busyThreads: number;
                  name: string;
                  poolSize: number;
                  ready: Promise<void>;
                  stopped: boolean;
                  start(...a: []): void;
                  stop(...a: []): void;
                  stopGracefully(
                      ...a: [opts?: { checkIntervalMs?: number; waitUpToMs?: number }],
                  ): Promise<{ remainingJobs: number; timedOut: boolean }>;
              };
              createUser(
                  ...a: [
                      input: {
                          email?: string;
                          name?: string;
                          password: string;
                          username: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { email: string
                  | null; name: string | null; username: string },
              >;
              deleteAuthorization(
                  ...a: [
                      input: { authorizationKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteDecisionInstance(
                  ...a: [
                      input: { decisionEvaluationKey: string; operationReference?: number },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteDecisionInstancesBatchOperation(
                  ...a: [
                      input: {
                          filter: {
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              decisionDefinitionId?: {
                                  __brand: "DecisionDefinitionId";
                                  readonly [key: number]: string;
                              };
                              decisionDefinitionKey?: | {
                                  __brand: "DecisionDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              decisionDefinitionName?: string;
                              decisionDefinitionType?: DecisionDefinitionTypeEnum;
                              decisionDefinitionVersion?: number;
                              decisionEvaluationInstanceKey?: | {
                                  __brand: "DecisionEvaluationInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionEvaluationInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionEvaluationInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              decisionEvaluationKey?: {
                                  __brand: "DecisionEvaluationKey";
                                  readonly [key: number]: string;
                              };
                              decisionRequirementsKey?: | {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionRequirementsKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionRequirementsKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              evaluationDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              evaluationFailure?: string;
                              processDefinitionKey?: {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              };
                              processInstanceKey?: {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              };
                              rootDecisionDefinitionKey?: | {
                                  __brand: "DecisionDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              state?: | DecisionInstanceStateEnum
                              | {
                                  $eq?: DecisionInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: DecisionInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: DecisionInstanceStateEnum | undefined;
                                  $notIn?: DecisionInstanceStateEnum[];
                              };
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          };
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              deleteDocument(
                  ...a: [
                      input: { documentId: string; storeId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteGlobalClusterVariable(
                  ...a: [
                      input: { name: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteGlobalTaskListener(
                  ...a: [
                      input: { id: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteGroup(
                  ...a: [
                      input: { groupId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteHistoryBackup(
                  ...a: [
                      input: { backupId: number },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteHistoryBackupAsClusterAdmin(
                  ...a: [
                      input: { backupId: number; physicalTenantId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteMappingRule(
                  ...a: [
                      input: { mappingRuleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteProcessInstance(
                  ...a: [
                      input: { operationReference?: number; processInstanceKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteProcessInstancesBatchOperation(
                  ...a: [
                      input: {
                          filter: {
                              $or?: {
                                  batchOperationId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  batchOperationKey?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementInstanceState?: | ElementInstanceStateEnum
                                  | {
                                      $eq?: ElementInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ElementInstanceStateEnum | undefined;
                                  };
                                  endDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  errorMessage?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  hasElementInstanceIncident?: boolean;
                                  hasIncident?: boolean;
                                  hasRetriesLeft?: boolean;
                                  incidentErrorHashCode?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  parentElementInstanceKey?: | {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  parentProcessInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionKey?: | {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionName?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionVersion?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  processDefinitionVersionTag?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  startDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  state?: | ProcessInstanceStateEnum
                                  | {
                                      $eq?: ProcessInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ProcessInstanceStateEnum | undefined;
                                  };
                                  suspendedDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  tags?: string[];
                                  tenantId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  variables?: { name: ...; value: ... }[];
                              }[];
                              batchOperationId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceState?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasElementInstanceIncident?: boolean;
                              hasIncident?: boolean;
                              hasRetriesLeft?: boolean;
                              incidentErrorHashCode?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              parentElementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              parentProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ProcessInstanceStateEnum
                              | {
                                  $eq?: ProcessInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ProcessInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ProcessInstanceStateEnum | undefined;
                              };
                              suspendedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              variables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                              }[];
                          };
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              deleteResource(
                  ...a: [
                      input: {
                          deleteHistory?: boolean;
                          operationReference?: number;
                          resourceKey: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperation: | {
                          batchOperationKey: string;
                          batchOperationType: BatchOperationTypeEnum;
                      }
                      | null;
                      resourceKey: string;
                  },
              >;
              deleteRole(
                  ...a: [
                      input: { roleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteRuntimeBackup(
                  ...a: [
                      input: { backupId: number },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteRuntimeBackupAsClusterAdmin(
                  ...a: [
                      input: { backupId: number; physicalTenantId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteRuntimeBackupState(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteRuntimeBackupStateAsClusterAdmin(
                  ...a: [
                      input: { physicalTenantId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteTenant(
                  ...a: [
                      input: { tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteTenantClusterVariable(
                  ...a: [
                      input: { name: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deleteUser(
                  ...a: [
                      input: { username: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              deployResourcesFromFiles(
                  ...a: [resourceFilenames: string[], options?: { tenantId?: string }],
              ): CancelablePromise<
                  {
                      decisionRequirements: {
                          decisionRequirementsId: string;
                          decisionRequirementsKey: string;
                          decisionRequirementsName: string;
                          resourceName: string;
                          tenantId: string;
                          version: number;
                      }[];
                      decisions: {
                          decisionDefinitionId: string;
                          decisionDefinitionKey: string;
                          decisionRequirementsId: string;
                          decisionRequirementsKey: string;
                          name: string;
                          tenantId: string;
                          version: number;
                      }[];
                      deploymentKey: string;
                      deployments: {
                          decisionDefinition: | {
                              decisionDefinitionId: string;
                              decisionDefinitionKey: string;
                              decisionRequirementsId: string;
                              decisionRequirementsKey: string;
                              name: string;
                              tenantId: string;
                              version: number;
                          }
                          | null;
                          decisionRequirements: | {
                              decisionRequirementsId: string;
                              decisionRequirementsKey: string;
                              decisionRequirementsName: string;
                              resourceName: string;
                              tenantId: string;
                              version: number;
                          }
                          | null;
                          form: | {
                              formId: string;
                              formKey: string;
                              resourceName: string;
                              tenantId: string;
                              version: number;
                          }
                          | null;
                          processDefinition: | {
                              processDefinitionId: string;
                              processDefinitionKey: string;
                              processDefinitionVersion: number;
                              resourceName: string;
                              tenantId: string;
                          }
                          | null;
                          resource: | {
                              resourceId: string;
                              resourceKey: string;
                              resourceName: string;
                              tenantId: string;
                              version: number;
                          }
                          | null;
                      }[];
                      forms: {
                          formId: string;
                          formKey: string;
                          resourceName: string;
                          tenantId: string;
                          version: number;
                      }[];
                      processes: {
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processDefinitionVersion: number;
                          resourceName: string;
                          tenantId: string;
                      }[];
                      resources: {
                          resourceId: string;
                          resourceKey: string;
                          resourceName: string;
                          tenantId: string;
                          version: number;
                      }[];
                      tenantId: string;
                  },
              >;
              emitSupportLogPreamble(...a: []): void;
              evaluateConditionals(
                  ...a: [
                      input: {
                          processDefinitionKey?: {
                              __brand: "ProcessDefinitionKey";
                              readonly [key: number]: string;
                          };
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          variables: { [key: string]: unknown };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      conditionalEvaluationKey: string;
                      processInstances: {
                          processDefinitionKey: string;
                          processInstanceKey: string;
                      }[];
                      tenantId: string;
                  },
              >;
              evaluateDecision(
                  ...a: [
                      input: | {
                          decisionDefinitionId: string;
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          variables?: { [key: string]: unknown };
                      }
                      | {
                          decisionDefinitionKey: string;
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          variables?: { [key: string]: unknown };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      decisionDefinitionId: string;
                      decisionDefinitionKey: string;
                      decisionDefinitionName: string;
                      decisionDefinitionVersion: number;
                      decisionEvaluationKey: string;
                      decisionInstanceKey: string;
                      decisionRequirementsId: string;
                      decisionRequirementsKey: string;
                      evaluatedDecisions: {
                          decisionDefinitionId: string;
                          decisionDefinitionKey: string;
                          decisionDefinitionName: string;
                          decisionDefinitionType: string;
                          decisionDefinitionVersion: number;
                          decisionEvaluationInstanceKey: string;
                          evaluatedInputs: {
                              inputId: string;
                              inputName: string;
                              inputValue: string;
                          }[];
                          matchedRules: {
                              evaluatedOutputs: {
                                  outputId: string;
                                  outputName: string;
                                  outputValue: string;
                                  ruleId: (...)
                                  | (...);
                                  ruleIndex: (...) | (...);
                              }[];
                              ruleId: string;
                              ruleIndex: number;
                          }[];
                          output: string;
                          tenantId: string;
                      }[];
                      failedDecisionDefinitionId: | {
                          __brand: "DecisionDefinitionId";
                          readonly [key: number]: string;
                      }
                      | null;
                      failureMessage: string
                      | null;
                      output: string;
                      tenantId: string;
                  },
              >;
              evaluateExpression(
                  ...a: [
                      input: {
                          expression: string;
                          scopeKey?: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | { __brand: "ElementInstanceKey"; readonly [key: number]: string };
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          variables?: { [key: string]: unknown } | null;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      expression: string;
                      referencedSecrets: { secretName: string; storeId: string }[];
                      result: unknown;
                      warnings: { message: string }[];
                  },
              >;
              failJob(
                  ...a: [
                      input: {
                          errorMessage?: string;
                          jobKey: string;
                          jobLeaseToken?: | {
                              __brand: "JobLeaseToken";
                              readonly [key: number]: string;
                          }
                          | null;
                          retries?: number;
                          retryBackOff?: number;
                          variables?: { [key: string]: unknown };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              forceAuthRefresh(...a: []): Promise<string | undefined>;
              getAgentDefinition(
                  ...a: [
                      input: { agentDefinitionKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          agentDefinitionKey: string;
                                          agentType: AgentDefinitionTypeEnum;
                                          elementId: string;
                                          name: string;
                                          processDefinitionId: string;
                                          processDefinitionKey: string;
                                          processDefinitionVersion: number;
                                          processDefinitionVersionTag: string
                                          | null;
                                          tenantId: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      agentDefinitionKey: string;
                      agentType: AgentDefinitionTypeEnum;
                      elementId: string;
                      name: string;
                      processDefinitionId: string;
                      processDefinitionKey: string;
                      processDefinitionVersion: number;
                      processDefinitionVersionTag: string
                      | null;
                      tenantId: string;
                  },
              >;
              getAgentInstance(
                  ...a: [
                      input: { agentInstanceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          agentDefinitionKey: string;
                                          agentInstanceKey: string;
                                          completionDate: string
                                          | null;
                                          creationDate: string;
                                          definition: {
                                              model: string;
                                              provider: string;
                                              systemPrompt: (...)[];
                                          };
                                          elementId: string;
                                          elementInstanceKeys: string[];
                                          lastUpdatedDate: string;
                                          limits: {
                                              maxModelCalls: number;
                                              maxTokens: number;
                                              maxToolCalls: number;
                                          };
                                          metrics: {
                                              cacheCreationTokenCount: number;
                                              cacheReadTokenCount: number;
                                              inputTokens: number;
                                              modelCalls: number;
                                              outputTokens: number;
                                              reasoningTokenCount: number;
                                              toolCalls: number;
                                          };
                                          processDefinitionId: string;
                                          processDefinitionKey: string;
                                          processDefinitionVersion: number;
                                          processDefinitionVersionTag: string
                                          | null;
                                          processInstanceKey: string;
                                          rootProcessInstanceKey: string;
                                          status: AgentInstanceStatusEnum;
                                          tenantId: string;
                                          tools: { description: ...; elementId: ...; name: ... }[];
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      agentDefinitionKey: string;
                      agentInstanceKey: string;
                      completionDate: string
                      | null;
                      creationDate: string;
                      definition: {
                          model: string;
                          provider: string;
                          systemPrompt: (
                              | { contentType: "TEXT"; text: string }
                              | {
                                  contentType: "DOCUMENT";
                                  documentReference: {
                                      "camunda.document.type": "camunda";
                                      contentHash: string | null;
                                      documentId: string;
                                      metadata: {
                                          contentType: string;
                                          customProperties: { [key: ...]: ... };
                                          expiresAt: (...) | (...);
                                          fileName: string;
                                          processDefinitionId: (...) | (...);
                                          processInstanceKey: (...) | (...);
                                          size: number;
                                      };
                                      storeId: string;
                                  };
                              }
                              | { contentType: "OBJECT"; object: unknown }
                          )[];
                      };
                      elementId: string;
                      elementInstanceKeys: string[];
                      lastUpdatedDate: string;
                      limits: {
                          maxModelCalls: number;
                          maxTokens: number;
                          maxToolCalls: number;
                      };
                      metrics: {
                          cacheCreationTokenCount: number;
                          cacheReadTokenCount: number;
                          inputTokens: number;
                          modelCalls: number;
                          outputTokens: number;
                          reasoningTokenCount: number;
                          toolCalls: number;
                      };
                      processDefinitionId: string;
                      processDefinitionKey: string;
                      processDefinitionVersion: number;
                      processDefinitionVersionTag: string
                      | null;
                      processInstanceKey: string;
                      rootProcessInstanceKey: string;
                      status: AgentInstanceStatusEnum;
                      tenantId: string;
                      tools: {
                          description: string | null;
                          elementId:
                              | { __brand: "ElementId"; readonly [key: number]: string }
                              | null;
                          name: string;
                      }[];
                  },
              >;
              getAuditLog(
                  ...a: [
                      input: { auditLogKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          actorId: string
                                          | null;
                                          actorType: AuditLogActorTypeEnum | null;
                                          agentElementId: string | null;
                                          auditLogKey: string;
                                          batchOperationKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          batchOperationType: BatchOperationTypeEnum | null;
                                          category: AuditLogCategoryEnum;
                                          decisionDefinitionId:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          decisionDefinitionKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          decisionEvaluationKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          decisionRequirementsId: string | null;
                                          decisionRequirementsKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          deploymentKey: { __brand: ...; readonly [key: ...]: ... } | null;
                                          elementInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          entityDescription: string | null;
                                          entityKey: string;
                                          entityType: AuditLogEntityTypeEnum;
                                          formKey: { __brand: ...; readonly [key: ...]: ... } | null;
                                          inboundChannelToolName: string | null;
                                          inboundChannelType: string | null;
                                          jobKey: { __brand: ...; readonly [key: ...]: ... } | null;
                                          operationType: AuditLogOperationTypeEnum;
                                          processDefinitionId:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          processDefinitionKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          processInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          relatedEntityKey: { __brand: ...; readonly [key: ...]: ... } | null;
                                          relatedEntityType: AuditLogEntityTypeEnum | null;
                                          resourceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          result: AuditLogResultEnum;
                                          rootProcessInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          tenantId: { __brand: ...; readonly [key: ...]: ... } | null;
                                          timestamp: string;
                                          userTaskKey: { __brand: ...; readonly [key: ...]: ... } | null;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      actorId: string
                      | null;
                      actorType: AuditLogActorTypeEnum | null;
                      agentElementId: string | null;
                      auditLogKey: string;
                      batchOperationKey:
                          | { __brand: "BatchOperationKey"; readonly [key: number]: string }
                          | null;
                      batchOperationType: BatchOperationTypeEnum | null;
                      category: AuditLogCategoryEnum;
                      decisionDefinitionId:
                          | {
                              __brand: "DecisionDefinitionId";
                              readonly [key: number]: string;
                          }
                          | null;
                      decisionDefinitionKey: | {
                          __brand: "DecisionDefinitionKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      decisionEvaluationKey: | {
                          __brand: "DecisionEvaluationKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      decisionRequirementsId: string
                      | null;
                      decisionRequirementsKey:
                          | {
                              __brand: "DecisionRequirementsKey";
                              readonly [key: number]: string;
                          }
                          | null;
                      deploymentKey: | {
                          __brand: "DeploymentKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      elementInstanceKey: | {
                          __brand: "ElementInstanceKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      entityDescription: string
                      | null;
                      entityKey: string;
                      entityType: AuditLogEntityTypeEnum;
                      formKey: { __brand: "FormKey"; readonly [key: number]: string } | null;
                      inboundChannelToolName: string | null;
                      inboundChannelType: string | null;
                      jobKey: { __brand: "JobKey"; readonly [key: number]: string } | null;
                      operationType: AuditLogOperationTypeEnum;
                      processDefinitionId:
                          | { __brand: "ProcessDefinitionId"; readonly [key: number]: string }
                          | null;
                      processDefinitionKey:
                          | {
                              __brand: "ProcessDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | null;
                      processInstanceKey: | {
                          __brand: "ProcessInstanceKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      relatedEntityKey: | {
                          __brand: "AuditLogEntityKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      relatedEntityType: AuditLogEntityTypeEnum
                      | null;
                      resourceKey:
                          | {
                              __brand: "ProcessDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | {
                              __brand: "DecisionRequirementsKey";
                              readonly [key: number]: string;
                          }
                          | { __brand: "DecisionDefinitionKey"; readonly [key: number]: string }
                          | { __brand: "FormKey"; readonly [key: number]: string }
                          | null;
                      result: AuditLogResultEnum;
                      rootProcessInstanceKey:
                          | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                          | null;
                      tenantId: { __brand: "TenantId"; readonly [key: number]: string } | null;
                      timestamp: string;
                      userTaskKey:
                          | { __brand: "UserTaskKey"; readonly [key: number]: string }
                          | null;
                  },
              >;
              getAuthentication(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      authorizedComponents: string[];
                      c8Links: { [key: string]: string };
                      canLogout: boolean;
                      displayName: string | null;
                      email: string | null;
                      groups: string[];
                      isAnonymous: boolean;
                      roles: string[];
                      salesPlanType: string | null;
                      tenants: { description: string | null; name: string; tenantId: string }[];
                      username: { __brand: "Username"; readonly [key: number]: string } | null;
                  },
              >;
              getAuthHeaders(...a: []): Promise<{ [key: string]: string }>;
              getAuthorization(
                  ...a: [
                      input: { authorizationKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          authorizationKey: string;
                                          ownerId: string;
                                          ownerType: OwnerTypeEnum;
                                          permissionTypes: PermissionTypeEnum[];
                                          resourceId: string
                                          | null;
                                          resourcePropertyName: string | null;
                                          resourceType: ResourceTypeEnum;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      authorizationKey: string;
                      ownerId: string;
                      ownerType: OwnerTypeEnum;
                      permissionTypes: PermissionTypeEnum[];
                      resourceId: string
                      | null;
                      resourcePropertyName: string | null;
                      resourceType: ResourceTypeEnum;
                  },
              >;
              getBackpressureState(
                  ...a: [],
              ):
                  | {
                      backoffMs: number;
                      consecutive: number;
                      permitsCurrent: number;
                      permitsMax: number
                      | null;
                      severity: BackpressureSeverity;
                      waiters: number;
                  }
                  | {
                      consecutive: number;
                      permitsCurrent: number;
                      permitsMax: null;
                      severity: string;
                      waiters: number;
                  };
              getBatchOperation(
                  ...a: [
                      input: { batchOperationKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          actorId: string
                                          | null;
                                          actorType: AuditLogActorTypeEnum | null;
                                          batchOperationKey: string;
                                          batchOperationType: BatchOperationTypeEnum | null;
                                          endDate: string | null;
                                          errors: { message: ...; partitionId: ...; type: ... }[];
                                          operationsCompletedCount: number;
                                          operationsFailedCount: number;
                                          operationsTotalCount: number;
                                          startDate: string | null;
                                          state: BatchOperationStateEnum;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      actorId: string
                      | null;
                      actorType: AuditLogActorTypeEnum | null;
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum | null;
                      endDate: string | null;
                      errors: {
                          message: string;
                          partitionId: number;
                          type: "QUERY_FAILED" | "RESULT_BUFFER_SIZE_EXCEEDED";
                      }[];
                      operationsCompletedCount: number;
                      operationsFailedCount: number;
                      operationsTotalCount: number;
                      startDate: string
                      | null;
                      state: BatchOperationStateEnum;
                  },
              >;
              getClock(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ timestamp: string }>;
              getClusterExportingStatus(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ status: ExportingStatusCode }>;
              getClusterRebalance(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      lastCompletedRebalance: | {
                          finishedAt: string;
                          partitions: {
                              currentLeader: string
                              | null;
                              desiredLeader: string;
                              partitionId: number;
                              physicalTenantId: string;
                              progress: "COMPLETED" | "PENDING" | "TRANSFERRING";
                              result:
                                  | "CANCELLED"
                                  | "TRANSFERRED"
                                  | "ALREADY_LEADER"
                                  | "NOT_MEMBER"
                                  | "NOT_REPLICATING"
                                  | "UNREACHABLE"
                                  | "NOT_COORDINATOR"
                                  | "STALE_CONFIGURATION"
                                  | "TRANSFER_IN_PROGRESS"
                                  | "LAG_TOO_HIGH"
                                  | "LEADER_INITIALIZING"
                                  | "CONFIGURATION_CHANGE_IN_PROGRESS"
                                  | "PAUSE_FAILED"
                                  | "REPLICATION_TIMED_OUT"
                                  | "TIMEOUT_NOW_EXHAUSTED"
                                  | "LEADER_CHANGED"
                                  | "NO_LEADER"
                                  | "NO_RESPONSE"
                                  | "PHYSICAL_TENANT_DISABLED"
                                  | "PHYSICAL_TENANT_RECOVERING";
                          }[];
                          rebalanceId: number;
                          result: "COMPLETED"
                          | "FAILED"
                          | "CANCELLED";
                          startedAt: string;
                      }
                      | null;
                      partitions: {
                          currentLeader: string
                          | null;
                          desiredLeader: string;
                          partitionId: number;
                          physicalTenantId: string;
                          state: "BALANCED" | "UNBALANCED" | "TRANSFERRING";
                      }[];
                      runningRebalance: | {
                          cancelRequested: boolean;
                          dryRun: boolean;
                          partitions: {
                              currentLeader: string
                              | null;
                              desiredLeader: string;
                              partitionId: number;
                              physicalTenantId: string;
                              progress: "COMPLETED" | "PENDING" | "TRANSFERRING";
                              result:
                                  | "CANCELLED"
                                  | "TRANSFERRED"
                                  | "ALREADY_LEADER"
                                  | "NOT_MEMBER"
                                  | "NOT_REPLICATING"
                                  | "UNREACHABLE"
                                  | "NOT_COORDINATOR"
                                  | "STALE_CONFIGURATION"
                                  | "TRANSFER_IN_PROGRESS"
                                  | "LAG_TOO_HIGH"
                                  | "LEADER_INITIALIZING"
                                  | "CONFIGURATION_CHANGE_IN_PROGRESS"
                                  | "PAUSE_FAILED"
                                  | "REPLICATION_TIMED_OUT"
                                  | "TIMEOUT_NOW_EXHAUSTED"
                                  | "LEADER_CHANGED"
                                  | "NO_LEADER"
                                  | "NO_RESPONSE"
                                  | "PHYSICAL_TENANT_DISABLED"
                                  | "PHYSICAL_TENANT_RECOVERING";
                          }[];
                          rebalanceId: number;
                          startedAt: string;
                      }
                      | null;
                      state: "BALANCED"
                      | "BALANCING"
                      | "UNBALANCED";
                  },
              >;
              getClusterStatus(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ status: "HEALTHY" | "DEGRADED" | "DOWN" }>;
              getClusterTopology(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      brokers: {
                          brokerId: string;
                          host: string;
                          port: number;
                          version: string;
                      }[];
                      clusterId: string
                      | null;
                      clusterSize: number;
                      gatewayVersion: string | null;
                      physicalTenants: {
                          brokers: {
                              brokerId: string;
                              partitions: {
                                  health: (...) | (...) | (...);
                                  partitionId: number;
                                  role: (...) | (...) | (...);
                                  state: (...) | (...) | (...) | (...) | (...) | (...);
                              }[];
                          }[];
                          lastCompletedChangeId: string;
                          partitionsCount: number;
                          physicalTenantId: string;
                          replicationFactor: number;
                      }[];
                  },
              >;
              getClusterUpgradeStatus(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { status: "UNKNOWN"
                  | "MIGRATED"
                  | "MIGRATION_IN_PROGRESS" },
              >;
              getConfig(
                  ...a: [],
              ): {
                  __raw: { [key: string]: string | undefined };
                  auth: {
                      basic?: { password?: string; username?: string };
                      strategy: AuthStrategy;
                  };
                  backpressure: {
                      decayQuietMs: number;
                      enabled: boolean;
                      floor: number;
                      healthyRecoveryMultiplier: number;
                      initialMax: number;
                      maxWaiters: number;
                      observeOnly: boolean;
                      profile: string;
                      recoveryIntervalMs: number;
                      recoveryStep: number;
                      severeFactor: number;
                      severeThreshold: number;
                      softFactor: number;
                      unlimitedAfterHealthyMs: number;
                  };
                  defaultTenantId: string;
                  eventual?: { pollDefaultMs: number };
                  httpRetry: {
                      baseDelayMs: number;
                      maxAttempts: number;
                      maxDelayMs: number;
                  };
                  logLevel: "trace"
                  | "error"
                  | "silent"
                  | "warn"
                  | "info"
                  | "debug";
                  mtls?: {
                      ca?: string;
                      caPath?: string;
                      cert?: string;
                      certPath?: string;
                      key?: string;
                      keyPassphrase?: string;
                      keyPath?: string;
                  };
                  oauth: {
                      cacheDir?: string;
                      clientId?: string;
                      clientSecret?: string;
                      grantType: string;
                      oauthUrl: string;
                      retry: { baseDelayMs: number; max: number };
                      scope?: string;
                      timeoutMs: number;
                  };
                  restAddress: string;
                  restAddressExact: boolean;
                  supportLog?: { enabled: boolean; filePath: string };
                  telemetry?: { correlation: boolean; log: boolean };
                  tokenAudience: string;
                  validation: { raw: string; req: ValidationMode; res: ValidationMode };
                  workerDefaults?: {
                      jobTimeoutMs?: number;
                      maxParallelJobs?: number;
                      pollTimeoutMs?: number;
                      startupJitterMaxSeconds?: number;
                      workerName?: string;
                  };
              };
              getDecisionDefinition(
                  ...a: [
                      input: { decisionDefinitionKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          decisionDefinitionId: string;
                                          decisionDefinitionKey: string;
                                          decisionRequirementsId: string;
                                          decisionRequirementsKey: string;
                                          decisionRequirementsName: string;
                                          decisionRequirementsVersion: number;
                                          name: string;
                                          tenantId: string;
                                          version: number;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      decisionDefinitionId: string;
                      decisionDefinitionKey: string;
                      decisionRequirementsId: string;
                      decisionRequirementsKey: string;
                      decisionRequirementsName: string;
                      decisionRequirementsVersion: number;
                      name: string;
                      tenantId: string;
                      version: number;
                  },
              >;
              getDecisionDefinitionXml(
                  ...a: [
                      input: { decisionDefinitionKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (...a: [result: string]) => boolean | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<string>;
              getDecisionInstance(
                  ...a: [
                      input: { decisionEvaluationInstanceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          businessId: { __brand: ...; readonly [key: ...]: ... }
                                          | null;
                                          decisionDefinitionId: string;
                                          decisionDefinitionKey: string;
                                          decisionDefinitionName: string;
                                          decisionDefinitionType: DecisionDefinitionTypeEnum;
                                          decisionDefinitionVersion: number;
                                          decisionEvaluationInstanceKey: string;
                                          decisionEvaluationKey: string;
                                          elementInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          evaluatedInputs: { inputId: ...; inputName: ...; inputValue: ... }[];
                                          evaluationDate: string;
                                          evaluationFailure: string | null;
                                          matchedRules: {
                                              evaluatedOutputs: ...;
                                              ruleId: ...;
                                              ruleIndex: ...;
                                          }[];
                                          processDefinitionKey: | { __brand: ...; readonly [key: ...]: ... }
                                          | null;
                                          processInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          result: string;
                                          rootDecisionDefinitionKey: string;
                                          rootProcessInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          state: DecisionInstanceStateEnum;
                                          storageOrdinal: number | null;
                                          tenantId: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      businessId: | {
                          __brand: "BusinessId";
                          readonly [key: number]: string;
                      }
                      | null;
                      decisionDefinitionId: string;
                      decisionDefinitionKey: string;
                      decisionDefinitionName: string;
                      decisionDefinitionType: DecisionDefinitionTypeEnum;
                      decisionDefinitionVersion: number;
                      decisionEvaluationInstanceKey: string;
                      decisionEvaluationKey: string;
                      elementInstanceKey: | {
                          __brand: "ElementInstanceKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      evaluatedInputs: {
                          inputId: string;
                          inputName: string;
                          inputValue: string;
                      }[];
                      evaluationDate: string;
                      evaluationFailure: string
                      | null;
                      matchedRules: {
                          evaluatedOutputs: {
                              outputId: string;
                              outputName: string;
                              outputValue: string;
                              ruleId: string | null;
                              ruleIndex: number | null;
                          }[];
                          ruleId: string;
                          ruleIndex: number;
                      }[];
                      processDefinitionKey: | {
                          __brand: "ProcessDefinitionKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      processInstanceKey: | {
                          __brand: "ProcessInstanceKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      result: string;
                      rootDecisionDefinitionKey: string;
                      rootProcessInstanceKey: | {
                          __brand: "ProcessInstanceKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      state: DecisionInstanceStateEnum;
                      storageOrdinal: number
                      | null;
                      tenantId: string;
                  },
              >;
              getDecisionRequirements(
                  ...a: [
                      input: { decisionRequirementsKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          decisionRequirementsId: string;
                                          decisionRequirementsKey: string;
                                          decisionRequirementsName: string;
                                          resourceName: string;
                                          tenantId: string;
                                          version: number;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      decisionRequirementsId: string;
                      decisionRequirementsKey: string;
                      decisionRequirementsName: string;
                      resourceName: string;
                      tenantId: string;
                      version: number;
                  },
              >;
              getDecisionRequirementsXml(
                  ...a: [
                      input: { decisionRequirementsKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (...a: [result: string]) => boolean | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<string>;
              getDocument(
                  ...a: [
                      input: { contentHash?: string; documentId: string; storeId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{}>;
              getElementInstance(
                  ...a: [
                      input: { elementInstanceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          elementId: string;
                                          elementInstanceKey: string;
                                          elementName: string;
                                          endDate: string
                                          | null;
                                          hasIncident: boolean;
                                          incidentKey: { __brand: ...; readonly [key: ...]: ... } | null;
                                          processDefinitionId:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          processDefinitionKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          processInstanceKey: string;
                                          rootProcessInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          startDate: string;
                                          state: ElementInstanceStateEnum;
                                          tenantId: string;
                                          type:
                                              | "UNKNOWN"
                                              | "USER_TASK"
                                              | "UNSPECIFIED"
                                              | "PROCESS"
                                              | "SUB_PROCESS"
                                              | "EVENT_SUB_PROCESS"
                                              | "AD_HOC_SUB_PROCESS"
                                              | "AD_HOC_SUB_PROCESS_INNER_INSTANCE"
                                              | "START_EVENT"
                                              | "INTERMEDIATE_CATCH_EVENT"
                                              | "INTERMEDIATE_THROW_EVENT"
                                              | "BOUNDARY_EVENT"
                                              | "END_EVENT"
                                              | "SERVICE_TASK"
                                              | "RECEIVE_TASK"
                                              | "MANUAL_TASK"
                                              | "TASK"
                                              | "EXCLUSIVE_GATEWAY"
                                              | "INCLUSIVE_GATEWAY"
                                              | "PARALLEL_GATEWAY"
                                              | "EVENT_BASED_GATEWAY"
                                              | "SEQUENCE_FLOW"
                                              | "MULTI_INSTANCE_BODY"
                                              | "CALL_ACTIVITY"
                                              | "BUSINESS_RULE_TASK"
                                              | "SCRIPT_TASK"
                                              | "SEND_TASK";
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      elementId: string;
                      elementInstanceKey: string;
                      elementName: string;
                      endDate: string
                      | null;
                      hasIncident: boolean;
                      incidentKey:
                          | { __brand: "IncidentKey"; readonly [key: number]: string }
                          | null;
                      processDefinitionId:
                          | { __brand: "ProcessDefinitionId"; readonly [key: number]: string }
                          | null;
                      processDefinitionKey:
                          | {
                              __brand: "ProcessDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | null;
                      processInstanceKey: string;
                      rootProcessInstanceKey: | {
                          __brand: "ProcessInstanceKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      startDate: string;
                      state: ElementInstanceStateEnum;
                      tenantId: string;
                      type: | "UNKNOWN"
                      | "USER_TASK"
                      | "UNSPECIFIED"
                      | "PROCESS"
                      | "SUB_PROCESS"
                      | "EVENT_SUB_PROCESS"
                      | "AD_HOC_SUB_PROCESS"
                      | "AD_HOC_SUB_PROCESS_INNER_INSTANCE"
                      | "START_EVENT"
                      | "INTERMEDIATE_CATCH_EVENT"
                      | "INTERMEDIATE_THROW_EVENT"
                      | "BOUNDARY_EVENT"
                      | "END_EVENT"
                      | "SERVICE_TASK"
                      | "RECEIVE_TASK"
                      | "MANUAL_TASK"
                      | "TASK"
                      | "EXCLUSIVE_GATEWAY"
                      | "INCLUSIVE_GATEWAY"
                      | "PARALLEL_GATEWAY"
                      | "EVENT_BASED_GATEWAY"
                      | "SEQUENCE_FLOW"
                      | "MULTI_INSTANCE_BODY"
                      | "CALL_ACTIVITY"
                      | "BUSINESS_RULE_TASK"
                      | "SCRIPT_TASK"
                      | "SEND_TASK";
                  },
              >;
              getErrorMode(...a: []): "throw" | "result";
              getExportingStatus(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ status: ExportingStatusCode }>;
              getFormByKey(
                  ...a: [
                      input: { formKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          formId: string;
                                          formKey: string;
                                          schema: string;
                                          tenantId: string;
                                          version: number;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      formId: string;
                      formKey: string;
                      schema: string;
                      tenantId: string;
                      version: number;
                  },
              >;
              getGlobalClusterVariable(
                  ...a: [
                      input: { name: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          kind: ClusterVariableKindEnum;
                                          metadata: { [key: string]: (...)
                                          | (...) };
                                          name: string;
                                          scope: ClusterVariableScopeEnum;
                                          tenantId: string | null;
                                          value: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      kind: ClusterVariableKindEnum;
                      metadata: { [key: string]: string
                      | number };
                      name: string;
                      scope: ClusterVariableScopeEnum;
                      tenantId: string | null;
                      value: string;
                  },
              >;
              getGlobalJobStatistics(
                  ...a: [
                      input: { from: string; jobType?: string; to: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          completed: { count: number; lastUpdatedAt: (...)
                                          | (...) };
                                          created: { count: number; lastUpdatedAt: (...) | (...) };
                                          failed: { count: number; lastUpdatedAt: (...) | (...) };
                                          isIncomplete: boolean;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      completed: { count: number; lastUpdatedAt: string
                      | null };
                      created: { count: number; lastUpdatedAt: string | null };
                      failed: { count: number; lastUpdatedAt: string | null };
                      isIncomplete: boolean;
                  },
              >;
              getGlobalTaskListener(
                  ...a: [
                      input: { id: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          afterNonGlobal?: boolean;
                                          eventTypes: GlobalTaskListenerEventTypeEnum[];
                                          id: string;
                                          priority?: number;
                                          retries?: number;
                                          source: GlobalListenerSourceEnum;
                                          type?: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      afterNonGlobal?: boolean;
                      eventTypes: GlobalTaskListenerEventTypeEnum[];
                      id: string;
                      priority?: number;
                      retries?: number;
                      source: GlobalListenerSourceEnum;
                      type?: string;
                  },
              >;
              getGroup(
                  ...a: [
                      input: { groupId: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          description: string
                                          | null;
                                          groupId: string;
                                          name: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { description: string
                  | null; groupId: string; name: string },
              >;
              getHistoryBackup(
                  ...a: [
                      input: { backupId: number },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupId: number;
                      details: {
                          failures: string[];
                          snapshotName: string;
                          startTime: string
                          | null;
                          state: string | null;
                      }[];
                      failureReason: string
                      | null;
                      state: HistoryBackupStateCode;
                  },
              >;
              getHistoryBackupAsClusterAdmin(
                  ...a: [
                      input: { backupId: number; physicalTenantId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupId: number;
                      physicalTenants: {
                          details: {
                              failures: string[];
                              snapshotName: string;
                              startTime: string
                              | null;
                              state: string | null;
                          }[];
                          failureReason: string
                          | null;
                          physicalTenantId: string;
                          state: ClusterHistoryBackupTenantState;
                      }[];
                  },
              >;
              getIncident(
                  ...a: [
                      input: { incidentKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          creationTime: string;
                                          elementId: string;
                                          elementInstanceKey: string;
                                          errorMessage: string;
                                          errorType: IncidentErrorTypeEnum;
                                          incidentKey: string;
                                          jobKey: { __brand: ...; readonly [key: ...]: ... }
                                          | null;
                                          processDefinitionId: string;
                                          processDefinitionKey: string;
                                          processInstanceKey: string;
                                          rootProcessInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          state: IncidentStateEnum;
                                          storageOrdinal: number | null;
                                          tenantId: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      creationTime: string;
                      elementId: string;
                      elementInstanceKey: string;
                      errorMessage: string;
                      errorType: IncidentErrorTypeEnum;
                      incidentKey: string;
                      jobKey: { __brand: "JobKey"; readonly [key: number]: string }
                      | null;
                      processDefinitionId: string;
                      processDefinitionKey: string;
                      processInstanceKey: string;
                      rootProcessInstanceKey:
                          | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                          | null;
                      state: IncidentStateEnum;
                      storageOrdinal: number | null;
                      tenantId: string;
                  },
              >;
              getJobErrorStatistics(
                  ...a: [
                      input: {
                          filter: {
                              errorCode?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              from: string;
                              jobType: string;
                              to: string;
                          };
                          page?: {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { errorCode: ...; errorMessage: ...; workers: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { errorCode: string; errorMessage: string; workers: number }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              getJobTimeSeriesStatistics(
                  ...a: [
                      input: {
                          filter: {
                              from: string;
                              jobType: string;
                              resolution?: string;
                              to: string;
                          };
                          page?: {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { completed: ...; created: ...; failed: ...; time: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          completed: { count: number; lastUpdatedAt: string
                          | null };
                          created: { count: number; lastUpdatedAt: string | null };
                          failed: { count: number; lastUpdatedAt: string | null };
                          time: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              getJobTypeStatistics(
                  ...a: [
                      input: {
                          filter?: {
                              from: string;
                              jobType?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              to: string;
                          };
                          page?: {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              completed: ...;
                                              created: ...;
                                              failed: ...;
                                              jobType: ...;
                                              workers: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          completed: { count: number; lastUpdatedAt: string
                          | null };
                          created: { count: number; lastUpdatedAt: string | null };
                          failed: { count: number; lastUpdatedAt: string | null };
                          jobType: string;
                          workers: number;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              getJobWorkerStatistics(
                  ...a: [
                      input: {
                          filter: { from: string; jobType: string; to: string };
                          page?: {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              completed: ...;
                                              created: ...;
                                              failed: ...;
                                              worker: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          completed: { count: number; lastUpdatedAt: string
                          | null };
                          created: { count: number; lastUpdatedAt: string | null };
                          failed: { count: number; lastUpdatedAt: string | null };
                          worker: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              getLicense(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      expiresAt: string
                      | null;
                      isCommercial: boolean;
                      licenseType: string;
                      validLicense: boolean;
                  },
              >;
              getMappingRule(
                  ...a: [
                      input: { mappingRuleId: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          claimName: string;
                                          claimValue: string;
                                          mappingRuleId: string;
                                          name: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      claimName: string;
                      claimValue: string;
                      mappingRuleId: string;
                      name: string;
                  },
              >;
              getProcessDefinition(
                  ...a: [
                      input: { processDefinitionKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          hasStartForm: boolean;
                                          name: string
                                          | null;
                                          processDefinitionId: string;
                                          processDefinitionKey: string;
                                          resourceName: string;
                                          state: "ACTIVE" | "DRAINING" | "DELETED";
                                          tenantId: string;
                                          version: number;
                                          versionTag: string | null;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      hasStartForm: boolean;
                      name: string
                      | null;
                      processDefinitionId: string;
                      processDefinitionKey: string;
                      resourceName: string;
                      state: "ACTIVE" | "DRAINING" | "DELETED";
                      tenantId: string;
                      version: number;
                      versionTag: string | null;
                  },
              >;
              getProcessDefinitionInstanceStatistics(
                  ...a: [
                      input: {
                          page?: { from?: number; limit?: number };
                          sort?: {
                              field:
                                  | "processDefinitionId"
                                  | "activeInstancesWithIncidentCount"
                                  | "activeInstancesWithoutIncidentCount";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              activeInstancesWithIncidentCount: ...;
                                              activeInstancesWithoutIncidentCount: ...;
                                              hasMultipleVersions: ...;
                                              latestProcessDefinitionName: ...;
                                              processDefinitionId: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          activeInstancesWithIncidentCount: number;
                          activeInstancesWithoutIncidentCount: number;
                          hasMultipleVersions: boolean;
                          latestProcessDefinitionName: string
                          | null;
                          processDefinitionId: string;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              getProcessDefinitionInstanceVersionStatistics(
                  ...a: [
                      input: {
                          filter: {
                              processDefinitionId: string;
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          };
                          page?: { from?: number; limit?: number };
                          sort?: {
                              field:
                                  | "processDefinitionId"
                                  | "processDefinitionVersion"
                                  | "processDefinitionKey"
                                  | "processDefinitionName"
                                  | "activeInstancesWithIncidentCount"
                                  | "activeInstancesWithoutIncidentCount";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              activeInstancesWithIncidentCount: ...;
                                              activeInstancesWithoutIncidentCount: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processDefinitionName: ...;
                                              processDefinitionVersion: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          activeInstancesWithIncidentCount: number;
                          activeInstancesWithoutIncidentCount: number;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processDefinitionName: string
                          | null;
                          processDefinitionVersion: number;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              getProcessDefinitionMessageSubscriptionStatistics(
                  ...a: [
                      input: {
                          filter?: {
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              correlationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              inboundConnectorType?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              lastUpdatedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              messageName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              messageSubscriptionKey?: | {
                                  __brand: "MessageSubscriptionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "MessageSubscriptionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "MessageSubscriptionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              messageSubscriptionState?: | MessageSubscriptionStateEnum
                              | {
                                  $eq?: MessageSubscriptionStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: MessageSubscriptionStateEnum[];
                                  $like?: string;
                                  $neq?: MessageSubscriptionStateEnum | undefined;
                              };
                              messageSubscriptionType?: | MessageSubscriptionTypeEnum
                              | {
                                  $eq?: MessageSubscriptionTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: MessageSubscriptionTypeEnum[];
                                  $like?: string;
                                  $neq?: MessageSubscriptionTypeEnum | undefined;
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              toolName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              activeSubscriptions: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstancesWithActiveSubscriptions: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          activeSubscriptions: number;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processInstancesWithActiveSubscriptions: number;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              getProcessDefinitionStatistics(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: {
                                  batchOperationId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  batchOperationKey?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  elementId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  elementInstanceState?: | ElementInstanceStateEnum
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $like?: ...; $neq?: ... };
                                  endDate?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $gt?: ...;
                                          $gte?: ...;
                                          $in?: ...;
                                          $lt?: ...;
                                          $lte?: ...;
                                          $neq?: ...;
                                      };
                                  errorMessage?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  hasElementInstanceIncident?: boolean;
                                  hasIncident?: boolean;
                                  hasRetriesLeft?: boolean;
                                  incidentErrorHashCode?: | number
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $gt?: ...;
                                      $gte?: ...;
                                      $in?: ...;
                                      $lt?: ...;
                                      $lte?: ...;
                                      $neq?: ...;
                                  };
                                  parentElementInstanceKey?: | {
                                      __brand: ...;
                                      readonly [key: ...]: ...;
                                  }
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $neq?: ...; $notIn?: ... };
                                  parentProcessInstanceKey?:
                                      | { __brand: ...; readonly [key: ...]: ... }
                                      | { $eq?: ...; $exists?: ...; $in?: ...; $neq?: ...; $notIn?: ... };
                                  processInstanceKey?:
                                      | { __brand: ...; readonly [key: ...]: ... }
                                      | { $eq?: ...; $exists?: ...; $in?: ...; $neq?: ...; $notIn?: ... };
                                  startDate?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $gt?: ...;
                                          $gte?: ...;
                                          $in?: ...;
                                          $lt?: ...;
                                          $lte?: ...;
                                          $neq?: ...;
                                      };
                                  state?: | ProcessInstanceStateEnum
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $like?: ...; $neq?: ... };
                                  suspendedDate?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $gt?: ...;
                                          $gte?: ...;
                                          $in?: ...;
                                          $lt?: ...;
                                          $lte?: ...;
                                          $neq?: ...;
                                      };
                                  tags?: (...)[];
                                  tenantId?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $in?: ...;
                                          $like?: ...;
                                          $neq?: ...;
                                          $notIn?: ...;
                                      };
                                  variables?: (...)[];
                              }[];
                              batchOperationId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceState?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasElementInstanceIncident?: boolean;
                              hasIncident?: boolean;
                              hasRetriesLeft?: boolean;
                              incidentErrorHashCode?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              parentElementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              parentProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ProcessInstanceStateEnum
                              | {
                                  $eq?: ProcessInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ProcessInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ProcessInstanceStateEnum | undefined;
                              };
                              suspendedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              variables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[];
                          };
                          processDefinitionKey: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              active: ...;
                                              canceled: ...;
                                              completed: ...;
                                              elementId: ...;
                                              incidents: ...;
                                          }[];
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          active: number;
                          canceled: number;
                          completed: number;
                          elementId: string;
                          incidents: number;
                      }[];
                  },
              >;
              getProcessDefinitionXml(
                  ...a: [
                      input: { processDefinitionKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (...a: [result: string]) => boolean | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<string>;
              getProcessInstance(
                  ...a: [
                      input: { processInstanceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          businessId: { __brand: ...; readonly [key: ...]: ... }
                                          | null;
                                          endDate: string | null;
                                          hasIncident: boolean;
                                          parentElementInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          parentProcessInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          processDefinitionId: string;
                                          processDefinitionKey: string;
                                          processDefinitionName: string | null;
                                          processDefinitionVersion: number;
                                          processDefinitionVersionTag: string | null;
                                          processInstanceKey: string;
                                          rootProcessInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          startDate: string;
                                          state: ProcessInstanceStateEnum;
                                          storageOrdinal: number | null;
                                          suspendedDate: string | null;
                                          tags: string[];
                                          tenantId: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      businessId: | {
                          __brand: "BusinessId";
                          readonly [key: number]: string;
                      }
                      | null;
                      endDate: string
                      | null;
                      hasIncident: boolean;
                      parentElementInstanceKey:
                          | { __brand: "ElementInstanceKey"; readonly [key: number]: string }
                          | null;
                      parentProcessInstanceKey:
                          | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                          | null;
                      processDefinitionId: string;
                      processDefinitionKey: string;
                      processDefinitionName: string | null;
                      processDefinitionVersion: number;
                      processDefinitionVersionTag: string | null;
                      processInstanceKey: string;
                      rootProcessInstanceKey:
                          | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                          | null;
                      startDate: string;
                      state: ProcessInstanceStateEnum;
                      storageOrdinal: number | null;
                      suspendedDate: string | null;
                      tags: string[];
                      tenantId: string;
                  },
              >;
              getProcessInstanceCallHierarchy(
                  ...a: [
                      input: { processInstanceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          processDefinitionKey: string;
                                          processDefinitionName: string;
                                          processInstanceKey: string;
                                      }[],
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      processDefinitionKey: string;
                      processDefinitionName: string;
                      processInstanceKey: string;
                  }[],
              >;
              getProcessInstanceSequenceFlows(
                  ...a: [
                      input: { processInstanceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              elementId: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              sequenceFlowId: ...;
                                              tenantId: ...;
                                          }[];
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          elementId: string;
                          processDefinitionId: | {
                              __brand: "ProcessDefinitionId";
                              readonly [key: number]: string;
                          }
                          | null;
                          processDefinitionKey: | {
                              __brand: "ProcessDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          processInstanceKey: string;
                          rootProcessInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          sequenceFlowId: string;
                          tenantId: string;
                      }[];
                  },
              >;
              getProcessInstanceStatistics(
                  ...a: [
                      input: { processInstanceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              active: ...;
                                              canceled: ...;
                                              completed: ...;
                                              elementId: ...;
                                              incidents: ...;
                                          }[];
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          active: number;
                          canceled: number;
                          completed: number;
                          elementId: string;
                          incidents: number;
                      }[];
                  },
              >;
              getProcessInstanceStatisticsByDefinition(
                  ...a: [
                      input: {
                          filter: { errorHashCode: number };
                          page?: { from?: number; limit?: number };
                          sort?: {
                              field:
                                  | "tenantId"
                                  | "processDefinitionKey"
                                  | "activeInstancesWithErrorCount";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              activeInstancesWithErrorCount: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processDefinitionName: ...;
                                              processDefinitionVersion: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          activeInstancesWithErrorCount: number;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processDefinitionName: string;
                          processDefinitionVersion: number;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              getProcessInstanceStatisticsByError(
                  ...a: [
                      input: {
                          page?: { from?: number; limit?: number };
                          sort?: {
                              field: "errorMessage" | "activeInstancesWithErrorCount";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              activeInstancesWithErrorCount: ...;
                                              errorHashCode: ...;
                                              errorMessage: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          activeInstancesWithErrorCount: number;
                          errorHashCode: number;
                          errorMessage: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              getProcessInstanceWaitStateStatistics(
                  ...a: [
                      input: { processInstanceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [result: { items: { elementId: ...; waitingCount: ... }[] }],
                              ) => boolean | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { items: { elementId: string; waitingCount: number }[] },
              >;
              getResource(
                  ...a: [
                      input: { resourceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          resourceId: string;
                                          resourceKey: string;
                                          resourceName: string;
                                          tenantId: string;
                                          version: number;
                                          versionTag: string
                                          | null;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      resourceId: string;
                      resourceKey: string;
                      resourceName: string;
                      tenantId: string;
                      version: number;
                      versionTag: string
                      | null;
                  },
              >;
              getResourceContent(
                  ...a: [
                      input: { resourceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [result: { [key: string]: unknown }],
                              ) => boolean | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ [key: string]: unknown }>;
              getResourceContentBinary(
                  ...a: [
                      input: { resourceKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (...a: [result: {}]) => boolean | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{}>;
              getRestoreStatus(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      brokers: {
                          brokerId: string;
                          partitions: {
                              backupIds: number[];
                              completedAt: string
                              | null;
                              partitionId: number;
                              state: "PENDING" | "RESTORING" | "RESTORED";
                          }[];
                          partitionsRestored: number;
                          partitionsToRestore: number;
                      }[];
                      changeId: string;
                      startedAt: string
                      | null;
                      status: "COMPLETED" | "FAILED" | "IN_PROGRESS" | "CANCELLED";
                  },
              >;
              getRole(
                  ...a: [
                      input: { roleId: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          description: string
                                          | null;
                                          name: string;
                                          roleId: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { description: string
                  | null; name: string; roleId: string },
              >;
              getRuntimeBackup(
                  ...a: [
                      input: { backupId: number },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupId: number;
                      details: {
                          brokerId: number
                          | null;
                          brokerVersion: string | null;
                          checkpointPosition: number | null;
                          createdAt: string | null;
                          failureReason: string | null;
                          firstLogPosition: number | null;
                          lastUpdatedAt: string | null;
                          partitionId: number;
                          snapshotId: string | null;
                          state: StateCode;
                      }[];
                      failureReason: string
                      | null;
                      state: StateCode;
                  },
              >;
              getRuntimeBackupAsClusterAdmin(
                  ...a: [
                      input: { backupId: number; physicalTenantId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupId: number;
                      failureReason: string
                      | null;
                      physicalTenants: {
                          details: {
                              brokerId: number | null;
                              brokerVersion: string | null;
                              checkpointPosition: number | null;
                              createdAt: string | null;
                              failureReason: string | null;
                              firstLogPosition: number | null;
                              lastUpdatedAt: string | null;
                              partitionId: number;
                              snapshotId: string | null;
                              state: StateCode;
                          }[];
                          failureReason: string
                          | null;
                          physicalTenantId: string;
                          state: StateCode;
                      }[];
                      state: StateCode;
                  },
              >;
              getRuntimeBackupState(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupStates: {
                          checkpointId: number;
                          checkpointPosition: number;
                          checkpointTimestamp: string;
                          checkpointType: BackupType;
                          firstLogPosition: number;
                          partitionId: number
                          | null;
                      }[];
                      checkpointStates: {
                          checkpointId: number;
                          checkpointPosition: number;
                          checkpointTimestamp: string;
                          checkpointType: CheckpointType;
                          partitionId: number;
                      }[];
                      ranges: {
                          end: | {
                              checkpointId: number;
                              checkpointPosition: number;
                              checkpointTimestamp: string;
                              checkpointType: BackupType;
                              firstLogPosition: number;
                              partitionId: number
                              | null;
                          }
                          | null;
                          partitionId: number;
                          start: | {
                              checkpointId: number;
                              checkpointPosition: number;
                              checkpointTimestamp: string;
                              checkpointType: BackupType;
                              firstLogPosition: number;
                              partitionId: number
                              | null;
                          }
                          | null;
                      }[];
                  },
              >;
              getRuntimeBackupStateAsClusterAdmin(
                  ...a: [
                      input: { physicalTenantId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      physicalTenants: {
                          physicalTenantId: string;
                          state: {
                              backupStates: {
                                  checkpointId: number;
                                  checkpointPosition: number;
                                  checkpointTimestamp: string;
                                  checkpointType: BackupType;
                                  firstLogPosition: number;
                                  partitionId: number
                                  | null;
                              }[];
                              checkpointStates: {
                                  checkpointId: number;
                                  checkpointPosition: number;
                                  checkpointTimestamp: string;
                                  checkpointType: CheckpointType;
                                  partitionId: number;
                              }[];
                              ranges: {
                                  end: | {
                                      checkpointId: ...;
                                      checkpointPosition: ...;
                                      checkpointTimestamp: ...;
                                      checkpointType: ...;
                                      firstLogPosition: ...;
                                      partitionId: ...;
                                  }
                                  | null;
                                  partitionId: number;
                                  start: | {
                                      checkpointId: ...;
                                      checkpointPosition: ...;
                                      checkpointTimestamp: ...;
                                      checkpointType: ...;
                                      firstLogPosition: ...;
                                      partitionId: ...;
                                  }
                                  | null;
                              }[];
                          };
                      }[];
                  },
              >;
              getStartProcessForm(
                  ...a: [
                      input: { processDefinitionKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: | void
                                      | {
                                          formId: string;
                                          formKey: string;
                                          schema: string;
                                          tenantId: string;
                                          version: number;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  | void
                  | {
                      formId: string;
                      formKey: string;
                      schema: string;
                      tenantId: string;
                      version: number;
                  },
              >;
              getStatus(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              getSystemConfiguration(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      authentication: {
                          canLogout: boolean;
                          isCamundaGroupsEnabled: boolean;
                          isLoginDelegated: boolean;
                      };
                      cloud: { stage: CloudStage
                      | null };
                      components: { active: WebappComponent[] };
                      deployment: {
                          isMultiTenancyEnabled: boolean;
                          isTenantsApiEnabled: boolean;
                          maxRequestSize: number;
                      };
                      jobMetrics: {
                          enabled: boolean;
                          exportInterval: string;
                          maxJobTypeLength: number;
                          maxTenantIdLength: number;
                          maxUniqueKeys: number;
                          maxWorkerNameLength: number;
                      };
                  },
              >;
              getTenant(
                  ...a: [
                      input: { tenantId: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          description: string
                                          | null;
                                          name: string;
                                          tenantId: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { description: string
                  | null; name: string; tenantId: string },
              >;
              getTenantClusterVariable(
                  ...a: [
                      input: { name: string; tenantId: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          kind: ClusterVariableKindEnum;
                                          metadata: { [key: string]: (...)
                                          | (...) };
                                          name: string;
                                          scope: ClusterVariableScopeEnum;
                                          tenantId: string | null;
                                          value: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      kind: ClusterVariableKindEnum;
                      metadata: { [key: string]: string
                      | number };
                      name: string;
                      scope: ClusterVariableScopeEnum;
                      tenantId: string | null;
                      value: string;
                  },
              >;
              getTopology(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      brokers: {
                          brokerId: string;
                          host: string;
                          nodeId: number;
                          partitions: {
                              health: "healthy"
                              | "unhealthy"
                              | "dead";
                              partitionId: number;
                              role: "leader" | "follower" | "inactive";
                              state:
                                  | "unknown"
                                  | "joining"
                                  | "active"
                                  | "leaving"
                                  | "recovering"
                                  | "learner";
                          }[];
                          port: number;
                          version: string;
                      }[];
                      clusterId: string
                      | null;
                      clusterSize: number;
                      gatewayVersion: string;
                      lastCompletedChangeId: string;
                      partitionsCount: number;
                      replicationFactor: number;
                  },
              >;
              getUsageMetrics(
                  ...a: [
                      input: {
                          endTime: string;
                          startTime: string;
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          withTenants?: boolean;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          activeTenants: number;
                                          assignees: number;
                                          decisionInstances: number;
                                          processInstances: number;
                                          tenants: {
                                              [key: string]: {
                                                  assignees: ...;
                                                  decisionInstances: ...;
                                                  processInstances: ...;
                                              };
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      activeTenants: number;
                      assignees: number;
                      decisionInstances: number;
                      processInstances: number;
                      tenants: {
                          [key: string]: {
                              assignees: number;
                              decisionInstances: number;
                              processInstances: number;
                          };
                      };
                  },
              >;
              getUser(
                  ...a: [
                      input: { username: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          email: string
                                          | null;
                                          name: string | null;
                                          username: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { email: string
                  | null; name: string | null; username: string },
              >;
              getUserTask(
                  ...a: [
                      input: { userTaskKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          assignee: string
                                          | null;
                                          businessId: { __brand: ...; readonly [key: ...]: ... } | null;
                                          candidateGroups: string[];
                                          candidateUsers: string[];
                                          completionDate: string | null;
                                          creationDate: string;
                                          customHeaders: { [key: string]: string };
                                          dueDate: string | null;
                                          elementId: string;
                                          elementInstanceKey: string;
                                          externalFormReference: string | null;
                                          followUpDate: string | null;
                                          formKey: { __brand: ...; readonly [key: ...]: ... } | null;
                                          isSuspended: boolean;
                                          name: string | null;
                                          priority: number;
                                          processDefinitionId: string;
                                          processDefinitionKey: string;
                                          processDefinitionVersion: number;
                                          processInstanceKey: string;
                                          processName: string | null;
                                          rootProcessInstanceKey:
                                              | { __brand: ...; readonly [key: ...]: ... }
                                              | null;
                                          state: UserTaskStateEnum;
                                          tags: string[];
                                          tenantId: string;
                                          userTaskKey: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      assignee: string
                      | null;
                      businessId:
                          | { __brand: "BusinessId"; readonly [key: number]: string }
                          | null;
                      candidateGroups: string[];
                      candidateUsers: string[];
                      completionDate: string | null;
                      creationDate: string;
                      customHeaders: { [key: string]: string };
                      dueDate: string | null;
                      elementId: string;
                      elementInstanceKey: string;
                      externalFormReference: string | null;
                      followUpDate: string | null;
                      formKey: { __brand: "FormKey"; readonly [key: number]: string } | null;
                      isSuspended: boolean;
                      name: string | null;
                      priority: number;
                      processDefinitionId: string;
                      processDefinitionKey: string;
                      processDefinitionVersion: number;
                      processInstanceKey: string;
                      processName: string | null;
                      rootProcessInstanceKey:
                          | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                          | null;
                      state: UserTaskStateEnum;
                      tags: string[];
                      tenantId: string;
                      userTaskKey: string;
                  },
              >;
              getUserTaskForm(
                  ...a: [
                      input: { userTaskKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: | void
                                      | {
                                          formId: string;
                                          formKey: string;
                                          schema: string;
                                          tenantId: string;
                                          version: number;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  | void
                  | {
                      formId: string;
                      formKey: string;
                      schema: string;
                      tenantId: string;
                      version: number;
                  },
              >;
              getVariable(
                  ...a: [
                      input: { variableKey: string },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          name: string;
                                          processInstanceKey: string;
                                          rootProcessInstanceKey: | {
                                              __brand: ...;
                                              readonly [key: ...]: ...;
                                          }
                                          | null;
                                          scopeKey: string;
                                          tenantId: string;
                                          value: string;
                                          variableKey: string;
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      name: string;
                      processInstanceKey: string;
                      rootProcessInstanceKey: | {
                          __brand: "ProcessInstanceKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      scopeKey: string;
                      tenantId: string;
                      value: string;
                      variableKey: string;
                  },
              >;
              getWorkers(...a: []): any[];
              listHistoryBackups(
                  ...a: [
                      input: { prefix?: string; verbose?: boolean },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupId: number;
                      details: {
                          failures: string[];
                          snapshotName: string;
                          startTime: string
                          | null;
                          state: string | null;
                      }[];
                      failureReason: string
                      | null;
                      state: HistoryBackupStateCode;
                  }[],
              >;
              listHistoryBackupsAsClusterAdmin(
                  ...a: [
                      input: {
                          physicalTenantId?: string;
                          prefix?: string;
                          verbose?: boolean;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupId: number;
                      physicalTenants: {
                          details: {
                              failures: string[];
                              snapshotName: string;
                              startTime: string
                              | null;
                              state: string | null;
                          }[];
                          failureReason: string
                          | null;
                          physicalTenantId: string;
                          state: ClusterHistoryBackupTenantState;
                      }[];
                  }[],
              >;
              listRuntimeBackups(
                  ...a: [
                      input: { prefix?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupId: number;
                      details: {
                          brokerId: number
                          | null;
                          brokerVersion: string | null;
                          checkpointPosition: number | null;
                          createdAt: string | null;
                          failureReason: string | null;
                          firstLogPosition: number | null;
                          lastUpdatedAt: string | null;
                          partitionId: number;
                          snapshotId: string | null;
                          state: StateCode;
                      }[];
                      failureReason: string
                      | null;
                      state: StateCode;
                  }[],
              >;
              listRuntimeBackupsAsClusterAdmin(
                  ...a: [
                      input: { physicalTenantId?: string; prefix?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupId: number;
                      failureReason: string
                      | null;
                      physicalTenants: {
                          details: {
                              brokerId: number | null;
                              brokerVersion: string | null;
                              checkpointPosition: number | null;
                              createdAt: string | null;
                              failureReason: string | null;
                              firstLogPosition: number | null;
                              lastUpdatedAt: string | null;
                              partitionId: number;
                              snapshotId: string | null;
                              state: StateCode;
                          }[];
                          failureReason: string
                          | null;
                          physicalTenantId: string;
                          state: StateCode;
                      }[];
                      state: StateCode;
                  }[],
              >;
              listSecrets(
                  ...a: [
                      input: { [key: string]: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ references: string[] }>;
              logger(
                  ...a: [scope?: string],
              ): {
                  code(
                      ...a: [level: LogLevel, code: string, msg: string, data?: any],
                  ): void;
                  debug(...a: any[]): void;
                  error(...a: any[]): void;
                  info(...a: any[]): void;
                  level(...a: []): LogLevel;
                  scope(
                      ...a: [child: string],
                  ): { level: () => LogLevel; setLevel: (level: LogLevel) => void; setTransport: (t?: ((e: { level: LogLevel; scope: string; ts: number; args: any[]; code?: string | undefined; data?: any; }) => void) | undefined) => void; ... 7 more ...; code: (level: LogLevel, code: string, msg: string, data?: any) => void; };
                  setLevel(...a: [level: LogLevel]): void;
                  setTransport(
                      ...a: [
                          t?: (
                              ...a: [
                                  e: {
                                      args: any[];
                                      code?: string;
                                      data?: any;
                                      level: LogLevel;
                                      scope: string;
                                      ts: number;
                                  },
                              ],
                          ) => void,
                      ],
                  ): void;
                  silly(...a: any[]): void;
                  trace(...a: any[]): void;
                  warn(...a: any[]): void;
              };
              lookupUserTask(
                  ...a: [
                      input: { fetchVariables?: string[]; userTaskKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      assignee: string
                      | null;
                      businessId:
                          | { __brand: "BusinessId"; readonly [key: number]: string }
                          | null;
                      candidateGroups: string[];
                      candidateUsers: string[];
                      creationDate: string;
                      customHeaders: { [key: string]: string };
                      dueDate: string | null;
                      elementId: string;
                      elementInstanceKey: string;
                      externalFormReference: string | null;
                      followUpDate: string | null;
                      formKey: { __brand: "FormKey"; readonly [key: number]: string } | null;
                      priority: number;
                      processDefinitionId: string;
                      processDefinitionKey: string;
                      processDefinitionVersion: number;
                      processInstanceKey: string;
                      rootProcessInstanceKey:
                          | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                          | null;
                      state: UserTaskLookupStateEnum;
                      tags: string[];
                      tenantId: string;
                      userTaskKey: string;
                      variables: { [key: string]: unknown };
                  },
              >;
              migrateProcessInstance(
                  ...a: [
                      input: {
                          mappingInstructions: {
                              sourceElementId: string;
                              targetElementId: string;
                          }[];
                          operationReference?: number;
                          processInstanceKey: string;
                          targetProcessDefinitionKey: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              migrateProcessInstancesBatchOperation(
                  ...a: [
                      input: {
                          filter: {
                              $or?: {
                                  batchOperationId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  batchOperationKey?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementInstanceState?: | ElementInstanceStateEnum
                                  | {
                                      $eq?: ElementInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ElementInstanceStateEnum | undefined;
                                  };
                                  endDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  errorMessage?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  hasElementInstanceIncident?: boolean;
                                  hasIncident?: boolean;
                                  hasRetriesLeft?: boolean;
                                  incidentErrorHashCode?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  parentElementInstanceKey?: | {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  parentProcessInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionKey?: | {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionName?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionVersion?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  processDefinitionVersionTag?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  startDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  state?: | ProcessInstanceStateEnum
                                  | {
                                      $eq?: ProcessInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ProcessInstanceStateEnum | undefined;
                                  };
                                  suspendedDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  tags?: string[];
                                  tenantId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  variables?: { name: ...; value: ... }[];
                              }[];
                              batchOperationId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceState?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasElementInstanceIncident?: boolean;
                              hasIncident?: boolean;
                              hasRetriesLeft?: boolean;
                              incidentErrorHashCode?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              parentElementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              parentProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ProcessInstanceStateEnum
                              | {
                                  $eq?: ProcessInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ProcessInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ProcessInstanceStateEnum | undefined;
                              };
                              suspendedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              variables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                              }[];
                          };
                          migrationPlan: {
                              mappingInstructions: {
                                  sourceElementId: string;
                                  targetElementId: string;
                              }[];
                              targetProcessDefinitionKey: string;
                          };
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              modifyProcessInstance(
                  ...a: [
                      input: {
                          activateInstructions?: {
                              ancestorElementInstanceKey?: {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              };
                              elementId: string;
                              variableInstructions?: {
                                  scopeId?: (...)
                                  | (...);
                                  variables: { [key: ...]: ... };
                              }[];
                          }[];
                          moveInstructions?: {
                              ancestorScopeInstruction?: | {
                                  ancestorElementInstanceKey: string;
                                  ancestorScopeType: "direct";
                              }
                              | { ancestorScopeType: "inferred" }
                              | { ancestorScopeType: "sourceParent" };
                              sourceElementInstruction:
                                  | { sourceElementId: string; sourceType: "byId" }
                                  | { sourceElementInstanceKey: string; sourceType: "byKey" };
                              targetElementId: string;
                              variableInstructions?: {
                                  scopeId?: (...) | (...);
                                  variables: { [key: ...]: ... };
                              }[];
                          }[];
                          operationReference?: number;
                          processInstanceKey: string;
                          terminateInstructions?: (
                              { elementId: string }
                              | { elementInstanceKey: string }
                          )[];
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              modifyProcessInstancesBatchOperation(
                  ...a: [
                      input: {
                          filter: {
                              $or?: {
                                  batchOperationId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  batchOperationKey?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementInstanceState?: | ElementInstanceStateEnum
                                  | {
                                      $eq?: ElementInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ElementInstanceStateEnum | undefined;
                                  };
                                  endDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  errorMessage?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  hasElementInstanceIncident?: boolean;
                                  hasIncident?: boolean;
                                  hasRetriesLeft?: boolean;
                                  incidentErrorHashCode?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  parentElementInstanceKey?: | {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  parentProcessInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionKey?: | {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionName?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionVersion?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  processDefinitionVersionTag?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  startDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  state?: | ProcessInstanceStateEnum
                                  | {
                                      $eq?: ProcessInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ProcessInstanceStateEnum | undefined;
                                  };
                                  suspendedDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  tags?: string[];
                                  tenantId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  variables?: { name: ...; value: ... }[];
                              }[];
                              batchOperationId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceState?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasElementInstanceIncident?: boolean;
                              hasIncident?: boolean;
                              hasRetriesLeft?: boolean;
                              incidentErrorHashCode?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              parentElementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              parentProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ProcessInstanceStateEnum
                              | {
                                  $eq?: ProcessInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ProcessInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ProcessInstanceStateEnum | undefined;
                              };
                              suspendedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              variables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                              }[];
                          };
                          moveInstructions: { sourceElementId: string; targetElementId: string }[];
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              onAuthHeaders(
                  ...a: [
                      h: (
                          ...a: [headers: { [key: string]: string }],
                      ) => Promise<{ [key: string]: string }> | { [key: string]: string },
                  ],
              ): void;
              pauseClusterExporting(
                  ...a: [
                      input: { soft?: boolean },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              pauseExporting(
                  ...a: [
                      input: { soft?: boolean },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              pinClock(
                  ...a: [
                      input: { timestamp: number },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              publishMessage(
                  ...a: [
                      input: {
                          businessId?: {
                              __brand: "BusinessId";
                              readonly [key: number]: string;
                          };
                          correlationKey?: string;
                          messageId?: string;
                          name: string;
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          timeToLive?: number;
                          variables?: { [key: string]: unknown };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ messageKey: string; tenantId: string }>;
              resetClock(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              resolveIncident(
                  ...a: [
                      input: { incidentKey: string; operationReference?: number },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              resolveIncidentsBatchOperation(
                  ...a: [
                      input: {
                          filter: {
                              $or?: {
                                  batchOperationId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  batchOperationKey?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementInstanceState?: | ElementInstanceStateEnum
                                  | {
                                      $eq?: ElementInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ElementInstanceStateEnum | undefined;
                                  };
                                  endDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  errorMessage?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  hasElementInstanceIncident?: boolean;
                                  hasIncident?: boolean;
                                  hasRetriesLeft?: boolean;
                                  incidentErrorHashCode?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  parentElementInstanceKey?: | {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  parentProcessInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionKey?: | {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionName?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionVersion?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  processDefinitionVersionTag?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  startDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  state?: | ProcessInstanceStateEnum
                                  | {
                                      $eq?: ProcessInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ProcessInstanceStateEnum | undefined;
                                  };
                                  suspendedDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  tags?: string[];
                                  tenantId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  variables?: { name: ...; value: ... }[];
                              }[];
                              batchOperationId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceState?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasElementInstanceIncident?: boolean;
                              hasIncident?: boolean;
                              hasRetriesLeft?: boolean;
                              incidentErrorHashCode?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              parentElementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              parentProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ProcessInstanceStateEnum
                              | {
                                  $eq?: ProcessInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ProcessInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ProcessInstanceStateEnum | undefined;
                              };
                              suspendedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              variables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                              }[];
                          };
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              resolveProcessInstanceIncidents(
                  ...a: [
                      input: { processInstanceKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              resolveSecrets(
                  ...a: [
                      input: { references: string[] },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      errors: { code: SecretErrorCode; message: string; reference: string }[];
                      resolved: { reference: string; value: string }[];
                  },
              >;
              restore(
                  ...a: [
                      input: {
                          backupIds?: number[]
                          | null;
                          dryRun?: boolean;
                          from?: string | null;
                          to?: string | null;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      changeId: string;
                      plannedChanges: {
                          operations: (
                              | {
                                  brokerId: string;
                                  operation: "UpdateIncarnationNumberOperation";
                              }
                              | {
                                  brokerId: string;
                                  operation: "PartitionPreRestoreOperation";
                                  partitionId: number;
                              }
                              | {
                                  backupIds: number[];
                                  brokerId: string;
                                  operation: "PartitionRestoreOperation";
                                  partitionId: number;
                              }
                              | { brokerId: string; mode: string; operation: "ModeChangeOperation" }
                              | {
                                  brokerId: string;
                                  mode: string;
                                  operation: "AwaitModeChangeOperation";
                              }
                          )[];
                          physicalTenantId: string
                          | null;
                      }[];
                  },
              >;
              restoreAsClusterAdmin(
                  ...a: [
                      input: {
                          backupIds?: number[]
                          | null;
                          dryRun?: boolean;
                          from?: string | null;
                          overrides?:
                              | {
                                  [key: string]: {
                                      backupIds?: number[]
                                      | null;
                                      from?: string | null;
                                      to?: string | null;
                                  };
                              }
                              | null;
                          physicalTenantId?: string;
                          to?: string
                          | null;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      changeId: string;
                      plannedChanges: {
                          operations: (
                              | {
                                  brokerId: string;
                                  operation: "UpdateIncarnationNumberOperation";
                              }
                              | {
                                  brokerId: string;
                                  operation: "PartitionPreRestoreOperation";
                                  partitionId: number;
                              }
                              | {
                                  backupIds: number[];
                                  brokerId: string;
                                  operation: "PartitionRestoreOperation";
                                  partitionId: number;
                              }
                              | { brokerId: string; mode: string; operation: "ModeChangeOperation" }
                              | {
                                  brokerId: string;
                                  mode: string;
                                  operation: "AwaitModeChangeOperation";
                              }
                          )[];
                          physicalTenantId: string
                          | null;
                      }[];
                  },
              >;
              resumeBatchOperation(
                  ...a: [
                      input: { batchOperationKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              resumeClusterExporting(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              resumeExporting(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              resumeProcessDefinitions(
                  ...a: [
                      input: | {
                          includeProcessInstances?: boolean;
                          processDefinitionKey: string;
                      }
                      | {
                          includeProcessInstances?: boolean;
                          processDefinitionId: string;
                          processDefinitionVersion?: number;
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: | {
                          __brand: "BatchOperationKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      processDefinitions: {
                          outcome: "DRAINING"
                          | "RESUMED"
                          | "ALREADY_RESUMED";
                          processDefinitionKey: string;
                          processDefinitionVersion: number;
                      }[];
                  },
              >;
              resumeProcessInstance(
                  ...a: [
                      input: { operationReference?: number; processInstanceKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              resumeProcessInstancesBatchOperation(
                  ...a: [
                      input: {
                          filter: {
                              $or?: {
                                  batchOperationId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  batchOperationKey?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementInstanceState?: | ElementInstanceStateEnum
                                  | {
                                      $eq?: ElementInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ElementInstanceStateEnum | undefined;
                                  };
                                  endDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  errorMessage?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  hasElementInstanceIncident?: boolean;
                                  hasIncident?: boolean;
                                  hasRetriesLeft?: boolean;
                                  incidentErrorHashCode?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  parentElementInstanceKey?: | {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  parentProcessInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionKey?: | {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionName?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionVersion?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  processDefinitionVersionTag?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  startDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  state?: | ProcessInstanceStateEnum
                                  | {
                                      $eq?: ProcessInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ProcessInstanceStateEnum | undefined;
                                  };
                                  suspendedDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  tags?: string[];
                                  tenantId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  variables?: { name: ...; value: ... }[];
                              }[];
                              batchOperationId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceState?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasElementInstanceIncident?: boolean;
                              hasIncident?: boolean;
                              hasRetriesLeft?: boolean;
                              incidentErrorHashCode?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              parentElementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              parentProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ProcessInstanceStateEnum
                              | {
                                  $eq?: ProcessInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ProcessInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ProcessInstanceStateEnum | undefined;
                              };
                              suspendedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              variables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                              }[];
                          };
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              searchAgentDefinitions(
                  ...a: [
                      input: {
                          filter?: {
                              agentDefinitionKey?: | {
                                  __brand: "AgentDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "AgentDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "AgentDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              agentType?: | AgentDefinitionTypeEnum
                              | {
                                  $eq?: AgentDefinitionTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AgentDefinitionTypeEnum[];
                                  $like?: string;
                                  $neq?: AgentDefinitionTypeEnum | undefined;
                                  $notIn?: AgentDefinitionTypeEnum[];
                              };
                              elementId?: | { __brand: "ElementId"; readonly [key: number]: string }
                              | {
                                  $eq?: { __brand: "ElementId"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: { __brand: "ElementId"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionId";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: {
                                      __brand: "ProcessDefinitionId";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processDefinitionId"
                              | "processDefinitionVersion"
                              | "elementId"
                              | "tenantId"
                              | "processDefinitionKey"
                              | "agentDefinitionKey"
                              | "agentType"
                              | "name"
                              | "processDefinitionVersionTag";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              agentDefinitionKey: ...;
                                              agentType: ...;
                                              elementId: ...;
                                              name: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processDefinitionVersion: ...;
                                              processDefinitionVersionTag: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          agentDefinitionKey: string;
                          agentType: AgentDefinitionTypeEnum;
                          elementId: string;
                          name: string;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processDefinitionVersion: number;
                          processDefinitionVersionTag: string
                          | null;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchAgentInstanceHistory(
                  ...a: [
                      input: {
                          agentInstanceKey: string;
                          filter?: {
                              commitStatus?: | AgentInstanceHistoryCommitStatusEnum
                              | {
                                  $eq?: AgentInstanceHistoryCommitStatusEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AgentInstanceHistoryCommitStatusEnum[];
                                  $neq?: AgentInstanceHistoryCommitStatusEnum | undefined;
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              historyItemKey?: | {
                                  __brand: "AgentHistoryItemKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "AgentHistoryItemKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "AgentHistoryItemKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              jobKey?: | { __brand: "JobKey"; readonly [key: number]: string }
                              | {
                                  $eq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              loopIteration?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              producedAt?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              role?: | AgentInstanceHistoryRoleEnum
                              | {
                                  $eq?: AgentInstanceHistoryRoleEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AgentInstanceHistoryRoleEnum[];
                                  $neq?: AgentInstanceHistoryRoleEnum | undefined;
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: "producedAt"
                              | "historyItemKey"
                              | "loopIteration";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              agentInstanceKey: ...;
                                              commitStatus: ...;
                                              content: ...;
                                              elementInstanceKey: ...;
                                              historyItemId: ...;
                                              historyItemKey: ...;
                                              jobKey: ...;
                                              jobLeaseToken: ...;
                                              limits: ...;
                                              loopIteration: ...;
                                              metrics: ...;
                                              model: ...;
                                              producedAt: ...;
                                              provider: ...;
                                              role: ...;
                                              systemPrompt: ...;
                                              toolCalls: ...;
                                              tools: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          agentInstanceKey: string;
                          commitStatus: AgentInstanceHistoryCommitStatusEnum;
                          content: (
                              | { contentType: "TEXT"; text: string }
                              | {
                                  contentType: "DOCUMENT";
                                  documentReference: {
                                      "camunda.document.type": "camunda";
                                      contentHash: (...) | (...);
                                      documentId: string;
                                      metadata: {
                                          contentType: ...;
                                          customProperties: ...;
                                          expiresAt: ...;
                                          fileName: ...;
                                          processDefinitionId: ...;
                                          processInstanceKey: ...;
                                          size: ...;
                                      };
                                      storeId: string;
                                  };
                              }
                              | { contentType: "OBJECT"; object: unknown }
                          )[];
                          elementInstanceKey: string;
                          historyItemId: string;
                          historyItemKey: string;
                          jobKey: string;
                          jobLeaseToken: string;
                          limits: {
                              maxModelCalls: number;
                              maxTokens: number;
                              maxToolCalls: number;
                          };
                          loopIteration: number;
                          metrics: | {
                              cacheCreationTokenCount: number
                              | null;
                              cacheReadTokenCount: number | null;
                              durationMs: number | null;
                              inputTokens: number | null;
                              outputTokens: number | null;
                              reasoningTokenCount: number | null;
                          }
                          | null;
                          model: string
                          | null;
                          producedAt: string;
                          provider: string | null;
                          role: AgentInstanceHistoryRoleEnum;
                          systemPrompt: (
                              | { contentType: "TEXT"; text: string }
                              | {
                                  contentType: "DOCUMENT";
                                  documentReference: {
                                      "camunda.document.type": "camunda";
                                      contentHash: (...) | (...);
                                      documentId: string;
                                      metadata: {
                                          contentType: ...;
                                          customProperties: ...;
                                          expiresAt: ...;
                                          fileName: ...;
                                          processDefinitionId: ...;
                                          processInstanceKey: ...;
                                          size: ...;
                                      };
                                      storeId: string;
                                  };
                              }
                              | { contentType: "OBJECT"; object: unknown }
                          )[];
                          toolCalls: {
                              arguments: { [key: string]: unknown } | null;
                              elementId:
                                  | { __brand: "ElementId"; readonly [key: number]: string }
                                  | null;
                              toolCallId: string;
                              toolName: string;
                          }[];
                          tools: {
                              description: string
                              | null;
                              elementId:
                                  | { __brand: "ElementId"; readonly [key: number]: string }
                                  | null;
                              name: string;
                          }[];
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchAgentInstances(
                  ...a: [
                      input: {
                          filter?: {
                              agentDefinitionKey?: | {
                                  __brand: "AgentDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "AgentDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "AgentDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              agentInstanceKey?: | {
                                  __brand: "AgentInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "AgentInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "AgentInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              completionDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              creationDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              elementId?: | { __brand: "ElementId"; readonly [key: number]: string }
                              | {
                                  $eq?: { __brand: "ElementId"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: { __brand: "ElementId"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              elementInstanceKeys?: (
                                  | {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  }
                              )[];
                              lastUpdatedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              rootProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              status?: | AgentInstanceStatusEnum
                              | {
                                  $eq?: AgentInstanceStatusEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AgentInstanceStatusEnum[];
                                  $like?: string;
                                  $neq?: AgentInstanceStatusEnum | undefined;
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "elementId"
                              | "tenantId"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "rootProcessInstanceKey"
                              | "agentDefinitionKey"
                              | "agentInstanceKey"
                              | "status"
                              | "creationDate"
                              | "lastUpdatedDate"
                              | "completionDate";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              agentDefinitionKey: ...;
                                              agentInstanceKey: ...;
                                              completionDate: ...;
                                              creationDate: ...;
                                              definition: ...;
                                              elementId: ...;
                                              elementInstanceKeys: ...;
                                              lastUpdatedDate: ...;
                                              limits: ...;
                                              metrics: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processDefinitionVersion: ...;
                                              processDefinitionVersionTag: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              status: ...;
                                              tenantId: ...;
                                              tools: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          agentDefinitionKey: string;
                          agentInstanceKey: string;
                          completionDate: string
                          | null;
                          creationDate: string;
                          definition: {
                              model: string;
                              provider: string;
                              systemPrompt: (
                                  | { contentType: "TEXT"; text: string }
                                  | {
                                      contentType: "DOCUMENT";
                                      documentReference: {
                                          "camunda.document.type": ...;
                                          contentHash: ...;
                                          documentId: ...;
                                          metadata: ...;
                                          storeId: ...;
                                      };
                                  }
                                  | { contentType: "OBJECT"; object: unknown }
                              )[];
                          };
                          elementId: string;
                          elementInstanceKeys: string[];
                          lastUpdatedDate: string;
                          limits: {
                              maxModelCalls: number;
                              maxTokens: number;
                              maxToolCalls: number;
                          };
                          metrics: {
                              cacheCreationTokenCount: number;
                              cacheReadTokenCount: number;
                              inputTokens: number;
                              modelCalls: number;
                              outputTokens: number;
                              reasoningTokenCount: number;
                              toolCalls: number;
                          };
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processDefinitionVersion: number;
                          processDefinitionVersionTag: string
                          | null;
                          processInstanceKey: string;
                          rootProcessInstanceKey: string;
                          status: AgentInstanceStatusEnum;
                          tenantId: string;
                          tools: {
                              description: string | null;
                              elementId:
                                  | { __brand: "ElementId"; readonly [key: number]: string }
                                  | null;
                              name: string;
                          }[];
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchAuditLogs(
                  ...a: [
                      input: {
                          filter?: {
                              actorId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              actorType?: | AuditLogActorTypeEnum
                              | {
                                  $eq?: AuditLogActorTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AuditLogActorTypeEnum[];
                                  $like?: string;
                                  $neq?: AuditLogActorTypeEnum | undefined;
                              };
                              agentElementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              auditLogKey?: | {
                                  __brand: "AuditLogKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: { __brand: "AuditLogKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "AuditLogKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              batchOperationType?: | BatchOperationTypeEnum
                              | {
                                  $eq?: BatchOperationTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: BatchOperationTypeEnum[];
                                  $like?: string;
                                  $neq?: BatchOperationTypeEnum | undefined;
                              };
                              category?: | AuditLogCategoryEnum
                              | {
                                  $eq?: AuditLogCategoryEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AuditLogCategoryEnum[];
                                  $like?: string;
                                  $neq?: AuditLogCategoryEnum | undefined;
                              };
                              decisionDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              decisionDefinitionKey?: | {
                                  __brand: "DecisionDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              decisionEvaluationKey?: | {
                                  __brand: "DecisionEvaluationKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionEvaluationKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionEvaluationKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              decisionRequirementsId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              decisionRequirementsKey?: | {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionRequirementsKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionRequirementsKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              deploymentKey?: | {
                                  __brand: "DeploymentKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: { __brand: "DeploymentKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "DeploymentKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              entityDescription?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              entityKey?: | {
                                  __brand: "AuditLogEntityKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "AuditLogEntityKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "AuditLogEntityKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              entityType?: | AuditLogEntityTypeEnum
                              | {
                                  $eq?: AuditLogEntityTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AuditLogEntityTypeEnum[];
                                  $like?: string;
                                  $neq?: AuditLogEntityTypeEnum | undefined;
                              };
                              formKey?: | { __brand: "FormKey"; readonly [key: number]: string }
                              | {
                                  $eq?: { __brand: "FormKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "FormKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              inboundChannelToolName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              inboundChannelType?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              jobKey?: | { __brand: "JobKey"; readonly [key: number]: string }
                              | {
                                  $eq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              operationType?: | AuditLogOperationTypeEnum
                              | {
                                  $eq?: AuditLogOperationTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AuditLogOperationTypeEnum[];
                                  $like?: string;
                                  $neq?: AuditLogOperationTypeEnum | undefined;
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              relatedEntityKey?: | {
                                  __brand: "AuditLogEntityKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "AuditLogEntityKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "AuditLogEntityKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              relatedEntityType?: | AuditLogEntityTypeEnum
                              | {
                                  $eq?: AuditLogEntityTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AuditLogEntityTypeEnum[];
                                  $like?: string;
                                  $neq?: AuditLogEntityTypeEnum | undefined;
                              };
                              resourceKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              }
                              | { __brand: "DecisionDefinitionKey"; readonly [key: number]: string }
                              | { __brand: "FormKey"; readonly [key: number]: string }
                              | {
                                  $eq?:
                                      | {
                                          __brand: "ProcessDefinitionKey";
                                          readonly [key: number]: string;
                                      }
                                      | {
                                          __brand: "DecisionRequirementsKey";
                                          readonly [key: number]: string;
                                      }
                                      | {
                                          __brand: "DecisionDefinitionKey";
                                          readonly [key: number]: string;
                                      }
                                      | { __brand: "FormKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?:
                                      | {
                                          __brand: "ProcessDefinitionKey";
                                          readonly [key: number]: string;
                                      }
                                      | {
                                          __brand: "DecisionRequirementsKey";
                                          readonly [key: number]: string;
                                      }
                                      | {
                                          __brand: "DecisionDefinitionKey";
                                          readonly [key: number]: string;
                                      }
                                      | { __brand: "FormKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              result?: | AuditLogResultEnum
                              | {
                                  $eq?: AuditLogResultEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AuditLogResultEnum[];
                                  $like?: string;
                                  $neq?: AuditLogResultEnum | undefined;
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              timestamp?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              userTaskKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processDefinitionId"
                              | "tenantId"
                              | "jobKey"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "elementInstanceKey"
                              | "result"
                              | "actorId"
                              | "actorType"
                              | "auditLogKey"
                              | "batchOperationKey"
                              | "batchOperationType"
                              | "category"
                              | "decisionDefinitionId"
                              | "decisionDefinitionKey"
                              | "decisionEvaluationKey"
                              | "decisionRequirementsId"
                              | "decisionRequirementsKey"
                              | "entityKey"
                              | "entityType"
                              | "operationType"
                              | "inboundChannelType"
                              | "inboundChannelToolName"
                              | "timestamp"
                              | "userTaskKey";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              actorId: ...;
                                              actorType: ...;
                                              agentElementId: ...;
                                              auditLogKey: ...;
                                              batchOperationKey: ...;
                                              batchOperationType: ...;
                                              category: ...;
                                              decisionDefinitionId: ...;
                                              decisionDefinitionKey: ...;
                                              decisionEvaluationKey: ...;
                                              decisionRequirementsId: ...;
                                              decisionRequirementsKey: ...;
                                              deploymentKey: ...;
                                              elementInstanceKey: ...;
                                              entityDescription: ...;
                                              entityKey: ...;
                                              entityType: ...;
                                              formKey: ...;
                                              inboundChannelToolName: ...;
                                              inboundChannelType: ...;
                                              jobKey: ...;
                                              operationType: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              relatedEntityKey: ...;
                                              relatedEntityType: ...;
                                              resourceKey: ...;
                                              result: ...;
                                              rootProcessInstanceKey: ...;
                                              tenantId: ...;
                                              timestamp: ...;
                                              userTaskKey: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          actorId: string
                          | null;
                          actorType: AuditLogActorTypeEnum | null;
                          agentElementId: string | null;
                          auditLogKey: string;
                          batchOperationKey:
                              | { __brand: "BatchOperationKey"; readonly [key: number]: string }
                              | null;
                          batchOperationType: BatchOperationTypeEnum | null;
                          category: AuditLogCategoryEnum;
                          decisionDefinitionId:
                              | {
                                  __brand: "DecisionDefinitionId";
                                  readonly [key: number]: string;
                              }
                              | null;
                          decisionDefinitionKey: | {
                              __brand: "DecisionDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          decisionEvaluationKey: | {
                              __brand: "DecisionEvaluationKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          decisionRequirementsId: string
                          | null;
                          decisionRequirementsKey:
                              | {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              }
                              | null;
                          deploymentKey: | {
                              __brand: "DeploymentKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          elementInstanceKey: | {
                              __brand: "ElementInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          entityDescription: string
                          | null;
                          entityKey: string;
                          entityType: AuditLogEntityTypeEnum;
                          formKey: { __brand: "FormKey"; readonly [key: number]: string } | null;
                          inboundChannelToolName: string | null;
                          inboundChannelType: string | null;
                          jobKey: { __brand: "JobKey"; readonly [key: number]: string } | null;
                          operationType: AuditLogOperationTypeEnum;
                          processDefinitionId:
                              | {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              }
                              | null;
                          processDefinitionKey: | {
                              __brand: "ProcessDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          processInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          relatedEntityKey: | {
                              __brand: "AuditLogEntityKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          relatedEntityType: AuditLogEntityTypeEnum
                          | null;
                          resourceKey:
                              | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              }
                              | { __brand: "DecisionDefinitionKey"; readonly [key: number]: string }
                              | { __brand: "FormKey"; readonly [key: number]: string }
                              | null;
                          result: AuditLogResultEnum;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          tenantId:
                              | { __brand: "TenantId"; readonly [key: number]: string }
                              | null;
                          timestamp: string;
                          userTaskKey:
                              | { __brand: "UserTaskKey"; readonly [key: number]: string }
                              | null;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchAuthorizations(
                  ...a: [
                      input: {
                          filter?: {
                              ownerId?: string;
                              ownerType?: OwnerTypeEnum;
                              resourceIds?: string[];
                              resourcePropertyNames?: string[];
                              resourceType?: ResourceTypeEnum;
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "ownerId"
                              | "ownerType"
                              | "resourceId"
                              | "resourcePropertyName"
                              | "resourceType";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              authorizationKey: ...;
                                              ownerId: ...;
                                              ownerType: ...;
                                              permissionTypes: ...;
                                              resourceId: ...;
                                              resourcePropertyName: ...;
                                              resourceType: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          authorizationKey: string;
                          ownerId: string;
                          ownerType: OwnerTypeEnum;
                          permissionTypes: PermissionTypeEnum[];
                          resourceId: string
                          | null;
                          resourcePropertyName: string | null;
                          resourceType: ResourceTypeEnum;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchBatchOperationItems(
                  ...a: [
                      input: {
                          filter?: {
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              itemKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              operationType?: | BatchOperationTypeEnum
                              | {
                                  $eq?: BatchOperationTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: BatchOperationTypeEnum[];
                                  $like?: string;
                                  $neq?: BatchOperationTypeEnum | undefined;
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              state?: | BatchOperationItemStateEnum
                              | {
                                  $eq?: BatchOperationItemStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: BatchOperationItemStateEnum[];
                                  $like?: string;
                                  $neq?: BatchOperationItemStateEnum | undefined;
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processInstanceKey"
                              | "batchOperationKey"
                              | "state"
                              | "itemKey"
                              | "processedDate";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              batchOperationKey: ...;
                                              errorMessage: ...;
                                              itemKey: ...;
                                              operationType: ...;
                                              processedDate: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              state: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          batchOperationKey: string;
                          errorMessage: string
                          | null;
                          itemKey: string;
                          operationType: BatchOperationTypeEnum;
                          processedDate: string | null;
                          processInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          state: "COMPLETED" | "ACTIVE" | "CANCELED" | "FAILED" | "SKIPPED";
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchBatchOperations(
                  ...a: [
                      input: {
                          filter?: {
                              actorId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              actorType?: AuditLogActorTypeEnum;
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              operationType?: | BatchOperationTypeEnum
                              | {
                                  $eq?: BatchOperationTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: BatchOperationTypeEnum[];
                                  $like?: string;
                                  $neq?: BatchOperationTypeEnum | undefined;
                              };
                              state?: | BatchOperationStateEnum
                              | {
                                  $eq?: BatchOperationStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: BatchOperationStateEnum[];
                                  $like?: string;
                                  $neq?: BatchOperationStateEnum | undefined;
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "actorId"
                              | "actorType"
                              | "batchOperationKey"
                              | "operationType"
                              | "state"
                              | "startDate"
                              | "endDate";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              actorId: ...;
                                              actorType: ...;
                                              batchOperationKey: ...;
                                              batchOperationType: ...;
                                              endDate: ...;
                                              errors: ...;
                                              operationsCompletedCount: ...;
                                              operationsFailedCount: ...;
                                              operationsTotalCount: ...;
                                              startDate: ...;
                                              state: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          actorId: string
                          | null;
                          actorType: AuditLogActorTypeEnum | null;
                          batchOperationKey: string;
                          batchOperationType: BatchOperationTypeEnum | null;
                          endDate: string | null;
                          errors: {
                              message: string;
                              partitionId: number;
                              type: "QUERY_FAILED" | "RESULT_BUFFER_SIZE_EXCEEDED";
                          }[];
                          operationsCompletedCount: number;
                          operationsFailedCount: number;
                          operationsTotalCount: number;
                          startDate: string
                          | null;
                          state: BatchOperationStateEnum;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchClientsForGroup(
                  ...a: [
                      input: {
                          groupId: string;
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "clientId"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { clientId: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { clientId: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchClientsForRole(
                  ...a: [
                      input: {
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          roleId: string;
                          sort?: { field: "clientId"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { clientId: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { clientId: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchClientsForTenant(
                  ...a: [
                      input: {
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "clientId"; order?: SortOrderEnum }[];
                          tenantId: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { clientId: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { clientId: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchClusterVariables(
                  ...a: [
                      input: {
                          filter?: {
                              isTruncated?: boolean;
                              kind?: | ClusterVariableKindEnum
                              | {
                                  $eq?: ClusterVariableKindEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ClusterVariableKindEnum[];
                                  $like?: string;
                                  $neq?: ClusterVariableKindEnum | undefined;
                              };
                              metadata?: {
                                  [key: string]: {
                                      $eq?: string
                                      | number;
                                      $exists?: boolean;
                                      $gt?: number;
                                      $gte?: number;
                                      $in?: (...)[];
                                      $like?: string;
                                      $lt?: number;
                                      $lte?: number;
                                      $neq?: string | number;
                                  };
                              };
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              scope?: | ClusterVariableScopeEnum
                              | {
                                  $eq?: ClusterVariableScopeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ClusterVariableScopeEnum[];
                                  $like?: string;
                                  $neq?: ClusterVariableScopeEnum | undefined;
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              value?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: "tenantId"
                              | "name"
                              | "value"
                              | "scope";
                              order?: SortOrderEnum;
                          }[];
                          truncateValues?: boolean;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              isTruncated: ...;
                                              kind: ...;
                                              metadata: ...;
                                              name: ...;
                                              scope: ...;
                                              tenantId: ...;
                                              value: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          isTruncated: boolean;
                          kind: ClusterVariableKindEnum;
                          metadata: { [key: string]: string
                          | number };
                          name: string;
                          scope: ClusterVariableScopeEnum;
                          tenantId: string | null;
                          value: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchCorrelatedMessageSubscriptions(
                  ...a: [
                      input: {
                          filter?: {
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              correlationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              correlationTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              messageKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              messageName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              partitionId?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              subscriptionKey?: | {
                                  __brand: "MessageSubscriptionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "MessageSubscriptionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "MessageSubscriptionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processDefinitionId"
                              | "elementId"
                              | "tenantId"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "elementInstanceKey"
                              | "businessId"
                              | "messageName"
                              | "correlationKey"
                              | "correlationTime"
                              | "messageKey"
                              | "partitionId"
                              | "subscriptionKey";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              businessId: ...;
                                              correlationKey: ...;
                                              correlationTime: ...;
                                              elementId: ...;
                                              elementInstanceKey: ...;
                                              messageKey: ...;
                                              messageName: ...;
                                              partitionId: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              subscriptionKey: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          businessId: | {
                              __brand: "BusinessId";
                              readonly [key: number]: string;
                          }
                          | null;
                          correlationKey: string
                          | null;
                          correlationTime: string;
                          elementId: string;
                          elementInstanceKey:
                              | { __brand: "ElementInstanceKey"; readonly [key: number]: string }
                              | null;
                          messageKey: string;
                          messageName: string;
                          partitionId: number;
                          processDefinitionId: string;
                          processDefinitionKey:
                              | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | null;
                          processInstanceKey: string;
                          rootProcessInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          subscriptionKey: string;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchDecisionDefinitions(
                  ...a: [
                      input: {
                          filter?: {
                              decisionDefinitionId?: {
                                  __brand: "DecisionDefinitionId";
                                  readonly [key: number]: string;
                              };
                              decisionDefinitionKey?: {
                                  __brand: "DecisionDefinitionKey";
                                  readonly [key: number]: string;
                              };
                              decisionRequirementsId?: string;
                              decisionRequirementsKey?: {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              };
                              decisionRequirementsName?: string;
                              decisionRequirementsVersion?: number;
                              isLatestVersion?: boolean;
                              name?: string;
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                              version?: number;
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "tenantId"
                              | "name"
                              | "decisionDefinitionId"
                              | "decisionDefinitionKey"
                              | "decisionRequirementsId"
                              | "decisionRequirementsKey"
                              | "version"
                              | "decisionRequirementsName"
                              | "decisionRequirementsVersion";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              decisionDefinitionId: ...;
                                              decisionDefinitionKey: ...;
                                              decisionRequirementsId: ...;
                                              decisionRequirementsKey: ...;
                                              decisionRequirementsName: ...;
                                              decisionRequirementsVersion: ...;
                                              name: ...;
                                              tenantId: ...;
                                              version: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          decisionDefinitionId: string;
                          decisionDefinitionKey: string;
                          decisionRequirementsId: string;
                          decisionRequirementsKey: string;
                          decisionRequirementsName: string;
                          decisionRequirementsVersion: number;
                          name: string;
                          tenantId: string;
                          version: number;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchDecisionInstances(
                  ...a: [
                      input: {
                          filter?: {
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              decisionDefinitionId?: {
                                  __brand: "DecisionDefinitionId";
                                  readonly [key: number]: string;
                              };
                              decisionDefinitionKey?: | {
                                  __brand: "DecisionDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              decisionDefinitionName?: string;
                              decisionDefinitionType?: DecisionDefinitionTypeEnum;
                              decisionDefinitionVersion?: number;
                              decisionEvaluationInstanceKey?: | {
                                  __brand: "DecisionEvaluationInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionEvaluationInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionEvaluationInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              decisionEvaluationKey?: {
                                  __brand: "DecisionEvaluationKey";
                                  readonly [key: number]: string;
                              };
                              decisionRequirementsKey?: | {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionRequirementsKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionRequirementsKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              evaluationDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              evaluationFailure?: string;
                              processDefinitionKey?: {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              };
                              processInstanceKey?: {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              };
                              rootDecisionDefinitionKey?: | {
                                  __brand: "DecisionDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "DecisionDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              state?: | DecisionInstanceStateEnum
                              | {
                                  $eq?: DecisionInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: DecisionInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: DecisionInstanceStateEnum | undefined;
                                  $notIn?: DecisionInstanceStateEnum[];
                              };
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "tenantId"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "elementInstanceKey"
                              | "businessId"
                              | "decisionDefinitionId"
                              | "decisionDefinitionKey"
                              | "decisionEvaluationKey"
                              | "state"
                              | "decisionDefinitionName"
                              | "decisionDefinitionType"
                              | "decisionDefinitionVersion"
                              | "decisionEvaluationInstanceKey"
                              | "evaluationDate"
                              | "evaluationFailure"
                              | "rootDecisionDefinitionKey";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              businessId: ...;
                                              decisionDefinitionId: ...;
                                              decisionDefinitionKey: ...;
                                              decisionDefinitionName: ...;
                                              decisionDefinitionType: ...;
                                              decisionDefinitionVersion: ...;
                                              decisionEvaluationInstanceKey: ...;
                                              decisionEvaluationKey: ...;
                                              elementInstanceKey: ...;
                                              evaluationDate: ...;
                                              evaluationFailure: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              result: ...;
                                              rootDecisionDefinitionKey: ...;
                                              rootProcessInstanceKey: ...;
                                              state: ...;
                                              storageOrdinal: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          businessId: | {
                              __brand: "BusinessId";
                              readonly [key: number]: string;
                          }
                          | null;
                          decisionDefinitionId: string;
                          decisionDefinitionKey: string;
                          decisionDefinitionName: string;
                          decisionDefinitionType: DecisionDefinitionTypeEnum;
                          decisionDefinitionVersion: number;
                          decisionEvaluationInstanceKey: string;
                          decisionEvaluationKey: string;
                          elementInstanceKey: | {
                              __brand: "ElementInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          evaluationDate: string;
                          evaluationFailure: string
                          | null;
                          processDefinitionKey:
                              | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | null;
                          processInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          result: string;
                          rootDecisionDefinitionKey: string;
                          rootProcessInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          state: DecisionInstanceStateEnum;
                          storageOrdinal: number
                          | null;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchDecisionRequirements(
                  ...a: [
                      input: {
                          filter?: {
                              decisionRequirementsId?: string;
                              decisionRequirementsKey?: {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              };
                              decisionRequirementsName?: string;
                              resourceName?: string;
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                              version?: number;
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "tenantId"
                              | "decisionRequirementsId"
                              | "decisionRequirementsKey"
                              | "version"
                              | "decisionRequirementsName";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              decisionRequirementsId: ...;
                                              decisionRequirementsKey: ...;
                                              decisionRequirementsName: ...;
                                              resourceName: ...;
                                              tenantId: ...;
                                              version: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          decisionRequirementsId: string;
                          decisionRequirementsKey: string;
                          decisionRequirementsName: string;
                          resourceName: string;
                          tenantId: string;
                          version: number;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchElementInstanceIncidents(
                  ...a: [
                      input: {
                          elementInstanceKey: string;
                          filter?: {
                              creationTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              errorType?: | IncidentErrorTypeEnum
                              | {
                                  $eq?: IncidentErrorTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: IncidentErrorTypeEnum[];
                                  $like?: string;
                                  $neq?: IncidentErrorTypeEnum | undefined;
                                  $notIn?: IncidentErrorTypeEnum[];
                              };
                              incidentKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              jobKey?: | { __brand: "JobKey"; readonly [key: number]: string }
                              | {
                                  $eq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              state?: | IncidentStateEnum
                              | {
                                  $eq?: IncidentStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: IncidentStateEnum[];
                                  $like?: string;
                                  $neq?: IncidentStateEnum | undefined;
                                  $notIn?: IncidentStateEnum[];
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processDefinitionId"
                              | "elementId"
                              | "tenantId"
                              | "jobKey"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "elementInstanceKey"
                              | "state"
                              | "incidentKey"
                              | "errorType"
                              | "creationTime";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              creationTime: ...;
                                              elementId: ...;
                                              elementInstanceKey: ...;
                                              errorMessage: ...;
                                              errorType: ...;
                                              incidentKey: ...;
                                              jobKey: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              state: ...;
                                              storageOrdinal: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          creationTime: string;
                          elementId: string;
                          elementInstanceKey: string;
                          errorMessage: string;
                          errorType: IncidentErrorTypeEnum;
                          incidentKey: string;
                          jobKey: { __brand: "JobKey"; readonly [key: number]: string }
                          | null;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processInstanceKey: string;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          state: IncidentStateEnum;
                          storageOrdinal: number | null;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchElementInstances(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: {
                                  elementId?: | { __brand: ...; readonly [key: ...]: ... }
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  elementInstanceKey?: { __brand: ...; readonly [key: ...]: ... };
                                  elementInstanceScopeKey?:
                                      | { __brand: ...; readonly [key: ...]: ... }
                                      | { __brand: ...; readonly [key: ...]: ... };
                                  elementName?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $in?: ...;
                                          $like?: ...;
                                          $neq?: ...;
                                          $notIn?: ...;
                                      };
                                  endDate?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $gt?: ...;
                                      $gte?: ...;
                                      $in?: ...;
                                      $lt?: ...;
                                      $lte?: ...;
                                      $neq?: ...;
                                  };
                                  hasIncident?: boolean;
                                  incidentKey?: { __brand: ...; readonly [key: ...]: ... };
                                  processDefinitionId?: { __brand: ...; readonly [key: ...]: ... };
                                  processDefinitionKey?: { __brand: ...; readonly [key: ...]: ... };
                                  processInstanceKey?: { __brand: ...; readonly [key: ...]: ... };
                                  startDate?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $gt?: ...;
                                          $gte?: ...;
                                          $in?: ...;
                                          $lt?: ...;
                                          $lte?: ...;
                                          $neq?: ...;
                                      };
                                  state?: | ElementInstanceStateEnum
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $like?: ...; $neq?: ... };
                                  tenantId?: { __brand: ...; readonly [key: ...]: ... };
                                  type?:
                                      | "UNKNOWN"
                                      | "USER_TASK"
                                      | "UNSPECIFIED"
                                      | "PROCESS"
                                      | "SUB_PROCESS"
                                      | "EVENT_SUB_PROCESS"
                                      | "AD_HOC_SUB_PROCESS"
                                      | "AD_HOC_SUB_PROCESS_INNER_INSTANCE"
                                      | "START_EVENT"
                                      | "INTERMEDIATE_CATCH_EVENT"
                                      | "INTERMEDIATE_THROW_EVENT"
                                      | "BOUNDARY_EVENT"
                                      | "END_EVENT"
                                      | "SERVICE_TASK"
                                      | "RECEIVE_TASK"
                                      | "MANUAL_TASK"
                                      | "TASK"
                                      | "EXCLUSIVE_GATEWAY"
                                      | "INCLUSIVE_GATEWAY"
                                      | "PARALLEL_GATEWAY"
                                      | "EVENT_BASED_GATEWAY"
                                      | "SEQUENCE_FLOW"
                                      | "MULTI_INSTANCE_BODY"
                                      | "CALL_ACTIVITY"
                                      | "BUSINESS_RULE_TASK"
                                      | "SCRIPT_TASK"
                                      | "SEND_TASK";
                              }[];
                              elementId?: | { __brand: "ElementId"; readonly [key: number]: string }
                              | {
                                  $eq?: { __brand: "ElementId"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: { __brand: "ElementId"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              };
                              elementInstanceScopeKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | { __brand: "ElementInstanceKey"; readonly [key: number]: string };
                              elementName?:
                                  | string
                                  | {
                                      $eq?: string;
                                      $exists?: boolean;
                                      $in?: string[];
                                      $like?: string;
                                      $neq?: string;
                                      $notIn?: string[];
                                  };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              hasIncident?: boolean;
                              incidentKey?: {
                                  __brand: "IncidentKey";
                                  readonly [key: number]: string;
                              };
                              processDefinitionId?: {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              };
                              processDefinitionKey?: {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              };
                              processInstanceKey?: {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                              type?:
                                  | "UNKNOWN"
                                  | "USER_TASK"
                                  | "UNSPECIFIED"
                                  | "PROCESS"
                                  | "SUB_PROCESS"
                                  | "EVENT_SUB_PROCESS"
                                  | "AD_HOC_SUB_PROCESS"
                                  | "AD_HOC_SUB_PROCESS_INNER_INSTANCE"
                                  | "START_EVENT"
                                  | "INTERMEDIATE_CATCH_EVENT"
                                  | "INTERMEDIATE_THROW_EVENT"
                                  | "BOUNDARY_EVENT"
                                  | "END_EVENT"
                                  | "SERVICE_TASK"
                                  | "RECEIVE_TASK"
                                  | "MANUAL_TASK"
                                  | "TASK"
                                  | "EXCLUSIVE_GATEWAY"
                                  | "INCLUSIVE_GATEWAY"
                                  | "PARALLEL_GATEWAY"
                                  | "EVENT_BASED_GATEWAY"
                                  | "SEQUENCE_FLOW"
                                  | "MULTI_INSTANCE_BODY"
                                  | "CALL_ACTIVITY"
                                  | "BUSINESS_RULE_TASK"
                                  | "SCRIPT_TASK"
                                  | "SEND_TASK";
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "type"
                              | "processDefinitionId"
                              | "elementId"
                              | "tenantId"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "elementInstanceKey"
                              | "state"
                              | "startDate"
                              | "endDate"
                              | "elementName"
                              | "incidentKey";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              elementId: ...;
                                              elementInstanceKey: ...;
                                              elementName: ...;
                                              endDate: ...;
                                              hasIncident: ...;
                                              incidentKey: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              startDate: ...;
                                              state: ...;
                                              tenantId: ...;
                                              type: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          elementId: string;
                          elementInstanceKey: string;
                          elementName: string;
                          endDate: string
                          | null;
                          hasIncident: boolean;
                          incidentKey:
                              | { __brand: "IncidentKey"; readonly [key: number]: string }
                              | null;
                          processDefinitionId:
                              | {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              }
                              | null;
                          processDefinitionKey: | {
                              __brand: "ProcessDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          processInstanceKey: string;
                          rootProcessInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          startDate: string;
                          state: ElementInstanceStateEnum;
                          tenantId: string;
                          type: | "UNKNOWN"
                          | "USER_TASK"
                          | "UNSPECIFIED"
                          | "PROCESS"
                          | "SUB_PROCESS"
                          | "EVENT_SUB_PROCESS"
                          | "AD_HOC_SUB_PROCESS"
                          | "AD_HOC_SUB_PROCESS_INNER_INSTANCE"
                          | "START_EVENT"
                          | "INTERMEDIATE_CATCH_EVENT"
                          | "INTERMEDIATE_THROW_EVENT"
                          | "BOUNDARY_EVENT"
                          | "END_EVENT"
                          | "SERVICE_TASK"
                          | "RECEIVE_TASK"
                          | "MANUAL_TASK"
                          | "TASK"
                          | "EXCLUSIVE_GATEWAY"
                          | "INCLUSIVE_GATEWAY"
                          | "PARALLEL_GATEWAY"
                          | "EVENT_BASED_GATEWAY"
                          | "SEQUENCE_FLOW"
                          | "MULTI_INSTANCE_BODY"
                          | "CALL_ACTIVITY"
                          | "BUSINESS_RULE_TASK"
                          | "SCRIPT_TASK"
                          | "SEND_TASK";
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchElementInstanceWaitStates(
                  ...a: [
                      input: {
                          filter?: {
                              elementId?: | {
                                  __brand: "ElementId";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: { __brand: "ElementId"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: { __brand: "ElementId"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              elementType?: | WaitStateElementTypeEnum
                              | {
                                  $eq?: WaitStateElementTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: WaitStateElementTypeEnum[];
                                  $like?: string;
                                  $neq?: WaitStateElementTypeEnum | undefined;
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              rootProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              waitStateType?: | WaitStateTypeEnum
                              | {
                                  $eq?: WaitStateTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: WaitStateTypeEnum[];
                                  $like?: string;
                                  $neq?: WaitStateTypeEnum | undefined;
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "elementId"
                              | "processInstanceKey"
                              | "elementInstanceKey"
                              | "rootProcessInstanceKey";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              bpmnProcessId: ...;
                                              details: ...;
                                              elementId: ...;
                                              elementInstanceKey: ...;
                                              elementType: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          bpmnProcessId: string;
                          details: | {
                              jobKey: string;
                              jobKind: JobKindEnum;
                              jobType: string;
                              listenerEventType: JobListenerEventTypeEnum
                              | null;
                              retries: number | null;
                              waitStateType: "JOB";
                          }
                          | {
                              correlationKey: string
                              | null;
                              messageName: string;
                              waitStateType: "MESSAGE";
                          }
                          | {
                              dueDate: string
                              | null;
                              taskKey: string;
                              waitStateType: "USER_TASK";
                          }
                          | {
                              dueDate: number
                              | null;
                              repetitions: number | null;
                              waitStateType: "TIMER";
                          }
                          | { signalName: string; waitStateType: "SIGNAL" }
                          | {
                              events: ("create" | "update")[];
                              expression: string;
                              waitStateType: "CONDITION";
                          };
                          elementId: string;
                          elementInstanceKey: string;
                          elementType: WaitStateElementTypeEnum;
                          processInstanceKey: string;
                          rootProcessInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchGlobalTaskListeners(
                  ...a: [
                      input: {
                          filter?: {
                              afterNonGlobal?: boolean;
                              eventTypes?: (
                                  | GlobalTaskListenerEventTypeEnum
                                  | {
                                      $eq?: GlobalTaskListenerEventTypeEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: GlobalTaskListenerEventTypeEnum | undefined;
                                  }
                              )[];
                              id?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              priority?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              retries?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              source?: | GlobalListenerSourceEnum
                              | {
                                  $eq?: GlobalListenerSourceEnum | undefined;
                                  $exists?: boolean;
                                  $in?: GlobalListenerSourceEnum[];
                                  $like?: string;
                                  $neq?: GlobalListenerSourceEnum | undefined;
                              };
                              type?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: "priority"
                              | "type"
                              | "id"
                              | "afterNonGlobal"
                              | "source";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              afterNonGlobal?: ...;
                                              eventTypes: ...;
                                              id: ...;
                                              priority?: ...;
                                              retries?: ...;
                                              source: ...;
                                              type?: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          afterNonGlobal?: boolean;
                          eventTypes: GlobalTaskListenerEventTypeEnum[];
                          id: string;
                          priority?: number;
                          retries?: number;
                          source: GlobalListenerSourceEnum;
                          type?: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchGroupIdsForTenant(
                  ...a: [
                      input: {
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "groupId"; order?: SortOrderEnum }[];
                          tenantId: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { groupId: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { groupId: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchGroups(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: | {
                                  groupId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  name?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[]
                              | null;
                              groupId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "name"
                          | "groupId"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { description: ...; groupId: ...; name: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { description: string
                      | null; groupId: string; name: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchGroupsForRole(
                  ...a: [
                      input: {
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          roleId: string;
                          sort?: { field: "groupId"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { groupId: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { groupId: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchIncidents(
                  ...a: [
                      input: {
                          filter?: {
                              creationTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              errorType?: | IncidentErrorTypeEnum
                              | {
                                  $eq?: IncidentErrorTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: IncidentErrorTypeEnum[];
                                  $like?: string;
                                  $neq?: IncidentErrorTypeEnum | undefined;
                                  $notIn?: IncidentErrorTypeEnum[];
                              };
                              incidentKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              jobKey?: | { __brand: "JobKey"; readonly [key: number]: string }
                              | {
                                  $eq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              state?: | IncidentStateEnum
                              | {
                                  $eq?: IncidentStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: IncidentStateEnum[];
                                  $like?: string;
                                  $neq?: IncidentStateEnum | undefined;
                                  $notIn?: IncidentStateEnum[];
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processDefinitionId"
                              | "elementId"
                              | "tenantId"
                              | "jobKey"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "elementInstanceKey"
                              | "state"
                              | "incidentKey"
                              | "errorType"
                              | "creationTime";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              creationTime: ...;
                                              elementId: ...;
                                              elementInstanceKey: ...;
                                              errorMessage: ...;
                                              errorType: ...;
                                              incidentKey: ...;
                                              jobKey: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              state: ...;
                                              storageOrdinal: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          creationTime: string;
                          elementId: string;
                          elementInstanceKey: string;
                          errorMessage: string;
                          errorType: IncidentErrorTypeEnum;
                          incidentKey: string;
                          jobKey: { __brand: "JobKey"; readonly [key: number]: string }
                          | null;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processInstanceKey: string;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          state: IncidentStateEnum;
                          storageOrdinal: number | null;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchJobs(
                  ...a: [
                      input: {
                          filter?: {
                              creationTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              deadline?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              }
                              | null;
                              deniedReason?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              endTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorCode?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasFailedWithRetriesLeft?: boolean;
                              isDenied?: boolean
                              | null;
                              jobKey?:
                                  | { __brand: "JobKey"; readonly [key: number]: string }
                                  | {
                                      $eq?: { __brand: "JobKey"; readonly [key: number]: string };
                                      $exists?: boolean;
                                      $in?: string[];
                                      $neq?: { __brand: "JobKey"; readonly [key: number]: string };
                                      $notIn?: string[];
                                  };
                              kind?: | JobKindEnum
                              | {
                                  $eq?: JobKindEnum | undefined;
                                  $exists?: boolean;
                                  $in?: JobKindEnum[];
                                  $like?: string;
                                  $neq?: JobKindEnum | undefined;
                              };
                              lastUpdateTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              listenerEventType?: | JobListenerEventTypeEnum
                              | {
                                  $eq?: JobListenerEventTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: JobListenerEventTypeEnum[];
                                  $like?: string;
                                  $neq?: JobListenerEventTypeEnum | undefined;
                              };
                              priority?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              retries?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              state?: | JobStateEnum
                              | {
                                  $eq?: JobStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: JobStateEnum[];
                                  $like?: string;
                                  $neq?: JobStateEnum | undefined;
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              type?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              worker?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "priority"
                              | "type"
                              | "processDefinitionId"
                              | "elementId"
                              | "worker"
                              | "retries"
                              | "deadline"
                              | "tenantId"
                              | "jobKey"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "elementInstanceKey"
                              | "kind"
                              | "listenerEventType"
                              | "state"
                              | "creationTime"
                              | "errorMessage"
                              | "deniedReason"
                              | "endTime"
                              | "errorCode"
                              | "hasFailedWithRetriesLeft"
                              | "isDenied";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              businessId: ...;
                                              creationTime: ...;
                                              customHeaders: ...;
                                              deadline: ...;
                                              deniedReason: ...;
                                              elementId: ...;
                                              elementInstanceKey: ...;
                                              endTime: ...;
                                              errorCode: ...;
                                              errorMessage: ...;
                                              hasFailedWithRetriesLeft: ...;
                                              isDenied: ...;
                                              jobKey: ...;
                                              kind: ...;
                                              lastUpdateTime: ...;
                                              listenerEventType: ...;
                                              priority: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              retries: ...;
                                              rootProcessInstanceKey: ...;
                                              state: ...;
                                              storageOrdinal: ...;
                                              tenantId: ...;
                                              type: ...;
                                              worker: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          businessId: | {
                              __brand: "BusinessId";
                              readonly [key: number]: string;
                          }
                          | null;
                          creationTime: string
                          | null;
                          customHeaders: { [key: string]: string };
                          deadline: string | null;
                          deniedReason: string | null;
                          elementId:
                              | { __brand: "ElementId"; readonly [key: number]: string }
                              | null;
                          elementInstanceKey: string;
                          endTime: string | null;
                          errorCode: string | null;
                          errorMessage: string | null;
                          hasFailedWithRetriesLeft: boolean;
                          isDenied: boolean | null;
                          jobKey: string;
                          kind: JobKindEnum;
                          lastUpdateTime: string | null;
                          listenerEventType: JobListenerEventTypeEnum;
                          priority: number;
                          processDefinitionId:
                              | {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              }
                              | null;
                          processDefinitionKey: | {
                              __brand: "ProcessDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          processInstanceKey: string;
                          retries: number;
                          rootProcessInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          state: JobStateEnum;
                          storageOrdinal: number
                          | null;
                          tenantId: string;
                          type: string;
                          worker: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchMappingRule(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: | {
                                  claimName?: string;
                                  claimValue?: string;
                                  mappingRuleId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  name?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[]
                              | null;
                              claimName?: string;
                              claimValue?: string;
                              mappingRuleId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: "name"
                              | "mappingRuleId"
                              | "claimName"
                              | "claimValue";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              claimName: ...;
                                              claimValue: ...;
                                              mappingRuleId: ...;
                                              name: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          claimName: string;
                          claimValue: string;
                          mappingRuleId: string;
                          name: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchMappingRulesForGroup(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: | {
                                  claimName?: string;
                                  claimValue?: string;
                                  mappingRuleId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  name?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[]
                              | null;
                              claimName?: string;
                              claimValue?: string;
                              mappingRuleId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          groupId: string;
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: "name"
                              | "mappingRuleId"
                              | "claimName"
                              | "claimValue";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              claimName: ...;
                                              claimValue: ...;
                                              mappingRuleId: ...;
                                              name: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          claimName: string;
                          claimValue: string;
                          mappingRuleId: string;
                          name: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchMappingRulesForRole(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: | {
                                  claimName?: string;
                                  claimValue?: string;
                                  mappingRuleId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  name?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[]
                              | null;
                              claimName?: string;
                              claimValue?: string;
                              mappingRuleId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          roleId: string;
                          sort?: {
                              field: "name"
                              | "mappingRuleId"
                              | "claimName"
                              | "claimValue";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              claimName: ...;
                                              claimValue: ...;
                                              mappingRuleId: ...;
                                              name: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          claimName: string;
                          claimValue: string;
                          mappingRuleId: string;
                          name: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchMappingRulesForTenant(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: | {
                                  claimName?: string;
                                  claimValue?: string;
                                  mappingRuleId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  name?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[]
                              | null;
                              claimName?: string;
                              claimValue?: string;
                              mappingRuleId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: "name"
                              | "mappingRuleId"
                              | "claimName"
                              | "claimValue";
                              order?: SortOrderEnum;
                          }[];
                          tenantId: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              claimName: ...;
                                              claimValue: ...;
                                              mappingRuleId: ...;
                                              name: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          claimName: string;
                          claimValue: string;
                          mappingRuleId: string;
                          name: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchMessageSubscriptions(
                  ...a: [
                      input: {
                          filter?: {
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              correlationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              inboundConnectorType?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              lastUpdatedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              messageName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              messageSubscriptionKey?: | {
                                  __brand: "MessageSubscriptionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "MessageSubscriptionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "MessageSubscriptionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              messageSubscriptionState?: | MessageSubscriptionStateEnum
                              | {
                                  $eq?: MessageSubscriptionStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: MessageSubscriptionStateEnum[];
                                  $like?: string;
                                  $neq?: MessageSubscriptionStateEnum | undefined;
                              };
                              messageSubscriptionType?: | MessageSubscriptionTypeEnum
                              | {
                                  $eq?: MessageSubscriptionTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: MessageSubscriptionTypeEnum[];
                                  $like?: string;
                                  $neq?: MessageSubscriptionTypeEnum | undefined;
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              toolName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processDefinitionId"
                              | "processDefinitionVersion"
                              | "elementId"
                              | "tenantId"
                              | "processInstanceKey"
                              | "elementInstanceKey"
                              | "businessId"
                              | "lastUpdatedDate"
                              | "messageSubscriptionKey"
                              | "processDefinitionName"
                              | "messageSubscriptionState"
                              | "messageSubscriptionType"
                              | "messageName"
                              | "correlationKey"
                              | "toolName"
                              | "inboundConnectorType";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              businessId: ...;
                                              correlationKey: ...;
                                              elementId: ...;
                                              elementInstanceKey: ...;
                                              inboundConnectorType: ...;
                                              lastUpdatedDate: ...;
                                              messageName: ...;
                                              messageSubscriptionKey: ...;
                                              messageSubscriptionState: ...;
                                              messageSubscriptionType: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processDefinitionName: ...;
                                              processDefinitionVersion: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              tenantId: ...;
                                              toolName: ...;
                                              toolProperties: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          businessId: | {
                              __brand: "BusinessId";
                              readonly [key: number]: string;
                          }
                          | null;
                          correlationKey: string
                          | null;
                          elementId: string;
                          elementInstanceKey:
                              | { __brand: "ElementInstanceKey"; readonly [key: number]: string }
                              | null;
                          inboundConnectorType: string | null;
                          lastUpdatedDate: string;
                          messageName: string;
                          messageSubscriptionKey: string;
                          messageSubscriptionState: MessageSubscriptionStateEnum;
                          messageSubscriptionType: MessageSubscriptionTypeEnum;
                          processDefinitionId: string;
                          processDefinitionKey:
                              | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | null;
                          processDefinitionName: string
                          | null;
                          processDefinitionVersion: number | null;
                          processInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          tenantId: string;
                          toolName: string | null;
                          toolProperties: { [key: string]: string };
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchOwnAuthorizations(
                  ...a: [
                      input: {
                          filter?: {
                              ownerId?: string;
                              ownerType?: OwnerTypeEnum;
                              resourceIds?: string[];
                              resourcePropertyNames?: string[];
                              resourceType?: ResourceTypeEnum;
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "ownerId"
                              | "ownerType"
                              | "resourceId"
                              | "resourcePropertyName"
                              | "resourceType";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          authorizationsEnabled: boolean;
                                          items: {
                                              authorizationKey: ...;
                                              ownerId: ...;
                                              ownerType: ...;
                                              permissionTypes: ...;
                                              resourceId: ...;
                                              resourcePropertyName: ...;
                                              resourceType: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      authorizationsEnabled: boolean;
                      items: {
                          authorizationKey: string;
                          ownerId: string;
                          ownerType: OwnerTypeEnum;
                          permissionTypes: PermissionTypeEnum[];
                          resourceId: string
                          | null;
                          resourcePropertyName: string | null;
                          resourceType: ResourceTypeEnum;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchProcessDefinitions(
                  ...a: [
                      input: {
                          filter?: {
                              hasStartForm?: boolean;
                              isLatestVersion?: boolean;
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              };
                              resourceName?: string;
                              state?: "ACTIVE"
                              | "DRAINING"
                              | "DELETED";
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                              version?: number;
                              versionTag?: string;
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processDefinitionId"
                              | "tenantId"
                              | "processDefinitionKey"
                              | "name"
                              | "version"
                              | "resourceName"
                              | "versionTag";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              hasStartForm: ...;
                                              name: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              resourceName: ...;
                                              state: ...;
                                              tenantId: ...;
                                              version: ...;
                                              versionTag: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          hasStartForm: boolean;
                          name: string
                          | null;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          resourceName: string;
                          state: "ACTIVE" | "DRAINING" | "DELETED";
                          tenantId: string;
                          version: number;
                          versionTag: string | null;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchProcessDefinitionVariableNames(
                  ...a: [
                      input: {
                          filter?: {
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          processDefinitionKey: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { name: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { name: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchProcessInstanceIncidents(
                  ...a: [
                      input: {
                          filter?: {
                              creationTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              errorType?: | IncidentErrorTypeEnum
                              | {
                                  $eq?: IncidentErrorTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: IncidentErrorTypeEnum[];
                                  $like?: string;
                                  $neq?: IncidentErrorTypeEnum | undefined;
                                  $notIn?: IncidentErrorTypeEnum[];
                              };
                              incidentKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              jobKey?: | { __brand: "JobKey"; readonly [key: number]: string }
                              | {
                                  $eq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "JobKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              state?: | IncidentStateEnum
                              | {
                                  $eq?: IncidentStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: IncidentStateEnum[];
                                  $like?: string;
                                  $neq?: IncidentStateEnum | undefined;
                                  $notIn?: IncidentStateEnum[];
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          processInstanceKey: string;
                          sort?: {
                              field: | "processDefinitionId"
                              | "elementId"
                              | "tenantId"
                              | "jobKey"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "elementInstanceKey"
                              | "state"
                              | "incidentKey"
                              | "errorType"
                              | "creationTime";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              creationTime: ...;
                                              elementId: ...;
                                              elementInstanceKey: ...;
                                              errorMessage: ...;
                                              errorType: ...;
                                              incidentKey: ...;
                                              jobKey: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              state: ...;
                                              storageOrdinal: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          creationTime: string;
                          elementId: string;
                          elementInstanceKey: string;
                          errorMessage: string;
                          errorType: IncidentErrorTypeEnum;
                          incidentKey: string;
                          jobKey: { __brand: "JobKey"; readonly [key: number]: string }
                          | null;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processInstanceKey: string;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          state: IncidentStateEnum;
                          storageOrdinal: number | null;
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchProcessInstances(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: {
                                  batchOperationId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  batchOperationKey?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  elementId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  elementInstanceState?: | ElementInstanceStateEnum
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $like?: ...; $neq?: ... };
                                  endDate?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $gt?: ...;
                                          $gte?: ...;
                                          $in?: ...;
                                          $lt?: ...;
                                          $lte?: ...;
                                          $neq?: ...;
                                      };
                                  errorMessage?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  hasElementInstanceIncident?: boolean;
                                  hasIncident?: boolean;
                                  hasRetriesLeft?: boolean;
                                  incidentErrorHashCode?: | number
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $gt?: ...;
                                      $gte?: ...;
                                      $in?: ...;
                                      $lt?: ...;
                                      $lte?: ...;
                                      $neq?: ...;
                                  };
                                  parentElementInstanceKey?: | {
                                      __brand: ...;
                                      readonly [key: ...]: ...;
                                  }
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $neq?: ...; $notIn?: ... };
                                  parentProcessInstanceKey?:
                                      | { __brand: ...; readonly [key: ...]: ... }
                                      | { $eq?: ...; $exists?: ...; $in?: ...; $neq?: ...; $notIn?: ... };
                                  processDefinitionId?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $in?: ...;
                                          $like?: ...;
                                          $neq?: ...;
                                          $notIn?: ...;
                                      };
                                  processDefinitionKey?: | { __brand: ...; readonly [key: ...]: ... }
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $neq?: ...; $notIn?: ... };
                                  processDefinitionName?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $in?: ...;
                                          $like?: ...;
                                          $neq?: ...;
                                          $notIn?: ...;
                                      };
                                  processDefinitionVersion?: | number
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $gt?: ...;
                                      $gte?: ...;
                                      $in?: ...;
                                      $lt?: ...;
                                      $lte?: ...;
                                      $neq?: ...;
                                  };
                                  processDefinitionVersionTag?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  processInstanceKey?: | { __brand: ...; readonly [key: ...]: ... }
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $neq?: ...; $notIn?: ... };
                                  startDate?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $gt?: ...;
                                          $gte?: ...;
                                          $in?: ...;
                                          $lt?: ...;
                                          $lte?: ...;
                                          $neq?: ...;
                                      };
                                  state?: | ProcessInstanceStateEnum
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $like?: ...; $neq?: ... };
                                  suspendedDate?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $gt?: ...;
                                          $gte?: ...;
                                          $in?: ...;
                                          $lt?: ...;
                                          $lte?: ...;
                                          $neq?: ...;
                                      };
                                  tags?: (...)[];
                                  tenantId?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $in?: ...;
                                          $like?: ...;
                                          $neq?: ...;
                                          $notIn?: ...;
                                      };
                                  variables?: (...)[];
                              }[];
                              batchOperationId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceState?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasElementInstanceIncident?: boolean;
                              hasIncident?: boolean;
                              hasRetriesLeft?: boolean;
                              incidentErrorHashCode?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              parentElementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              parentProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ProcessInstanceStateEnum
                              | {
                                  $eq?: ProcessInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ProcessInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ProcessInstanceStateEnum | undefined;
                              };
                              suspendedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              variables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[];
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processDefinitionId"
                              | "processDefinitionVersion"
                              | "tenantId"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "businessId"
                              | "processDefinitionVersionTag"
                              | "state"
                              | "startDate"
                              | "endDate"
                              | "processDefinitionName"
                              | "parentProcessInstanceKey"
                              | "parentElementInstanceKey"
                              | "suspendedDate"
                              | "hasIncident";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              businessId: ...;
                                              endDate: ...;
                                              hasIncident: ...;
                                              parentElementInstanceKey: ...;
                                              parentProcessInstanceKey: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processDefinitionName: ...;
                                              processDefinitionVersion: ...;
                                              processDefinitionVersionTag: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              startDate: ...;
                                              state: ...;
                                              storageOrdinal: ...;
                                              suspendedDate: ...;
                                              tags: ...;
                                              tenantId: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          businessId: | {
                              __brand: "BusinessId";
                              readonly [key: number]: string;
                          }
                          | null;
                          endDate: string
                          | null;
                          hasIncident: boolean;
                          parentElementInstanceKey:
                              | { __brand: "ElementInstanceKey"; readonly [key: number]: string }
                              | null;
                          parentProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processDefinitionName: string | null;
                          processDefinitionVersion: number;
                          processDefinitionVersionTag: string | null;
                          processInstanceKey: string;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          startDate: string;
                          state: ProcessInstanceStateEnum;
                          storageOrdinal: number | null;
                          suspendedDate: string | null;
                          tags: string[];
                          tenantId: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchResources(
                  ...a: [
                      input: {
                          filter?: {
                              deploymentKey?: | {
                                  __brand: "DeploymentKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: { __brand: "DeploymentKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "DeploymentKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              resourceId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              resourceKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              }
                              | { __brand: "DecisionDefinitionKey"; readonly [key: number]: string }
                              | { __brand: "FormKey"; readonly [key: number]: string }
                              | {
                                  $eq?:
                                      | {
                                          __brand: "ProcessDefinitionKey";
                                          readonly [key: number]: string;
                                      }
                                      | {
                                          __brand: "DecisionRequirementsKey";
                                          readonly [key: number]: string;
                                      }
                                      | {
                                          __brand: "DecisionDefinitionKey";
                                          readonly [key: number]: string;
                                      }
                                      | { __brand: "FormKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?:
                                      | {
                                          __brand: "ProcessDefinitionKey";
                                          readonly [key: number]: string;
                                      }
                                      | {
                                          __brand: "DecisionRequirementsKey";
                                          readonly [key: number]: string;
                                      }
                                      | {
                                          __brand: "DecisionDefinitionKey";
                                          readonly [key: number]: string;
                                      }
                                      | { __brand: "FormKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              resourceName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                              version?:
                                  | number
                                  | {
                                      $eq?: number;
                                      $exists?: boolean;
                                      $gt?: number;
                                      $gte?: number;
                                      $in?: number[];
                                      $lt?: number;
                                      $lte?: number;
                                      $neq?: number;
                                  };
                              versionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "tenantId"
                              | "resourceId"
                              | "version"
                              | "resourceKey"
                              | "resourceName"
                              | "versionTag"
                              | "deploymentKey";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              resourceId: ...;
                                              resourceKey: ...;
                                              resourceName: ...;
                                              tenantId: ...;
                                              version: ...;
                                              versionTag: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          resourceId: string;
                          resourceKey: string;
                          resourceName: string;
                          tenantId: string;
                          version: number;
                          versionTag: string
                          | null;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchRoles(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: | {
                                  name?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  roleId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[]
                              | null;
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              roleId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "name"
                          | "roleId"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { description: ...; name: ...; roleId: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { description: string
                      | null; name: string; roleId: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchRolesForGroup(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: | {
                                  name?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  roleId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[]
                              | null;
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              roleId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          groupId: string;
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "name"
                          | "roleId"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { description: ...; name: ...; roleId: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { description: string
                      | null; name: string; roleId: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchRolesForTenant(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: | {
                                  name?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  roleId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[]
                              | null;
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              roleId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "name"
                          | "roleId"; order?: SortOrderEnum }[];
                          tenantId: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { description: ...; name: ...; roleId: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { description: string
                      | null; name: string; roleId: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchTenants(
                  ...a: [
                      input: {
                          filter?: {
                              name?: string;
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "tenantId"
                          | "name"
                          | "key"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { description: ...; name: ...; tenantId: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { description: string
                      | null; name: string; tenantId: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchUsers(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: | {
                                  email?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  name?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  username?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[]
                              | null;
                              email?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              username?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "name"
                          | "username"
                          | "email"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { email: ...; name: ...; username: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          email: string
                          | null;
                          name: string | null;
                          username: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchUsersForGroup(
                  ...a: [
                      input: {
                          groupId: string;
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "username"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { username: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { username: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchUsersForRole(
                  ...a: [
                      input: {
                          filter?: {
                              username?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          roleId: string;
                          sort?: { field: "username"; order?: SortOrderEnum }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { username: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { username: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchUsersForTenant(
                  ...a: [
                      input: {
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: { field: "username"; order?: SortOrderEnum }[];
                          tenantId: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: { username: ... }[];
                                          page: {
                                              endCursor: (...) | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: { username: string }[];
                      page: {
                          endCursor:
                              | { __brand: "EndCursor"; readonly [key: number]: string }
                              | null;
                          hasMoreTotalItems: boolean;
                          startCursor:
                              | { __brand: "StartCursor"; readonly [key: number]: string }
                              | null;
                          totalItems: number;
                      };
                  },
              >;
              searchUserTaskAuditLogs(
                  ...a: [
                      input: {
                          filter?: {
                              actorId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              actorType?: | AuditLogActorTypeEnum
                              | {
                                  $eq?: AuditLogActorTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AuditLogActorTypeEnum[];
                                  $like?: string;
                                  $neq?: AuditLogActorTypeEnum | undefined;
                              };
                              operationType?: | AuditLogOperationTypeEnum
                              | {
                                  $eq?: AuditLogOperationTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AuditLogOperationTypeEnum[];
                                  $like?: string;
                                  $neq?: AuditLogOperationTypeEnum | undefined;
                              };
                              result?: | AuditLogResultEnum
                              | {
                                  $eq?: AuditLogResultEnum | undefined;
                                  $exists?: boolean;
                                  $in?: AuditLogResultEnum[];
                                  $like?: string;
                                  $neq?: AuditLogResultEnum | undefined;
                              };
                              timestamp?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "processDefinitionId"
                              | "tenantId"
                              | "jobKey"
                              | "processInstanceKey"
                              | "processDefinitionKey"
                              | "elementInstanceKey"
                              | "result"
                              | "actorId"
                              | "actorType"
                              | "auditLogKey"
                              | "batchOperationKey"
                              | "batchOperationType"
                              | "category"
                              | "decisionDefinitionId"
                              | "decisionDefinitionKey"
                              | "decisionEvaluationKey"
                              | "decisionRequirementsId"
                              | "decisionRequirementsKey"
                              | "entityKey"
                              | "entityType"
                              | "operationType"
                              | "inboundChannelType"
                              | "inboundChannelToolName"
                              | "timestamp"
                              | "userTaskKey";
                              order?: SortOrderEnum;
                          }[];
                          userTaskKey: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              actorId: ...;
                                              actorType: ...;
                                              agentElementId: ...;
                                              auditLogKey: ...;
                                              batchOperationKey: ...;
                                              batchOperationType: ...;
                                              category: ...;
                                              decisionDefinitionId: ...;
                                              decisionDefinitionKey: ...;
                                              decisionEvaluationKey: ...;
                                              decisionRequirementsId: ...;
                                              decisionRequirementsKey: ...;
                                              deploymentKey: ...;
                                              elementInstanceKey: ...;
                                              entityDescription: ...;
                                              entityKey: ...;
                                              entityType: ...;
                                              formKey: ...;
                                              inboundChannelToolName: ...;
                                              inboundChannelType: ...;
                                              jobKey: ...;
                                              operationType: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processInstanceKey: ...;
                                              relatedEntityKey: ...;
                                              relatedEntityType: ...;
                                              resourceKey: ...;
                                              result: ...;
                                              rootProcessInstanceKey: ...;
                                              tenantId: ...;
                                              timestamp: ...;
                                              userTaskKey: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          actorId: string
                          | null;
                          actorType: AuditLogActorTypeEnum | null;
                          agentElementId: string | null;
                          auditLogKey: string;
                          batchOperationKey:
                              | { __brand: "BatchOperationKey"; readonly [key: number]: string }
                              | null;
                          batchOperationType: BatchOperationTypeEnum | null;
                          category: AuditLogCategoryEnum;
                          decisionDefinitionId:
                              | {
                                  __brand: "DecisionDefinitionId";
                                  readonly [key: number]: string;
                              }
                              | null;
                          decisionDefinitionKey: | {
                              __brand: "DecisionDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          decisionEvaluationKey: | {
                              __brand: "DecisionEvaluationKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          decisionRequirementsId: string
                          | null;
                          decisionRequirementsKey:
                              | {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              }
                              | null;
                          deploymentKey: | {
                              __brand: "DeploymentKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          elementInstanceKey: | {
                              __brand: "ElementInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          entityDescription: string
                          | null;
                          entityKey: string;
                          entityType: AuditLogEntityTypeEnum;
                          formKey: { __brand: "FormKey"; readonly [key: number]: string } | null;
                          inboundChannelToolName: string | null;
                          inboundChannelType: string | null;
                          jobKey: { __brand: "JobKey"; readonly [key: number]: string } | null;
                          operationType: AuditLogOperationTypeEnum;
                          processDefinitionId:
                              | {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              }
                              | null;
                          processDefinitionKey: | {
                              __brand: "ProcessDefinitionKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          processInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          relatedEntityKey: | {
                              __brand: "AuditLogEntityKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          relatedEntityType: AuditLogEntityTypeEnum
                          | null;
                          resourceKey:
                              | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  __brand: "DecisionRequirementsKey";
                                  readonly [key: number]: string;
                              }
                              | { __brand: "DecisionDefinitionKey"; readonly [key: number]: string }
                              | { __brand: "FormKey"; readonly [key: number]: string }
                              | null;
                          result: AuditLogResultEnum;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          tenantId:
                              | { __brand: "TenantId"; readonly [key: number]: string }
                              | null;
                          timestamp: string;
                          userTaskKey:
                              | { __brand: "UserTaskKey"; readonly [key: number]: string }
                              | null;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchUserTaskEffectiveVariables(
                  ...a: [
                      input: {
                          filter?: {
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: { from?: number; limit?: number };
                          sort?: {
                              field:
                                  | "tenantId"
                                  | "processInstanceKey"
                                  | "name"
                                  | "value"
                                  | "variableKey"
                                  | "scopeKey";
                              order?: SortOrderEnum;
                          }[];
                          truncateValues?: boolean;
                          userTaskKey: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              isTruncated: ...;
                                              name: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              scopeKey: ...;
                                              tenantId: ...;
                                              value: ...;
                                              variableKey: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          isTruncated: boolean;
                          name: string;
                          processInstanceKey: string;
                          rootProcessInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          scopeKey: string;
                          tenantId: string;
                          value: string;
                          variableKey: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchUserTasks(
                  ...a: [
                      input: {
                          filter?: {
                              $or?: {
                                  assignee?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  candidateGroup?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  candidateUser?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  completionDate?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $gt?: ...;
                                      $gte?: ...;
                                      $in?: ...;
                                      $lt?: ...;
                                      $lte?: ...;
                                      $neq?: ...;
                                  };
                                  creationDate?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $gt?: ...;
                                      $gte?: ...;
                                      $in?: ...;
                                      $lt?: ...;
                                      $lte?: ...;
                                      $neq?: ...;
                                  };
                                  dueDate?: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $gt?: ...;
                                      $gte?: ...;
                                      $in?: ...;
                                      $lt?: ...;
                                      $lte?: ...;
                                      $neq?: ...;
                                  };
                                  elementId?: { __brand: ...; readonly [key: ...]: ... };
                                  elementInstanceKey?: { __brand: ...; readonly [key: ...]: ... };
                                  followUpDate?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $gt?: ...;
                                          $gte?: ...;
                                          $in?: ...;
                                          $lt?: ...;
                                          $lte?: ...;
                                          $neq?: ...;
                                      };
                                  isSuspended?: boolean;
                                  localVariables?: (...)[];
                                  name?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $in?: ...;
                                          $like?: ...;
                                          $neq?: ...;
                                          $notIn?: ...;
                                      };
                                  priority?: | number
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $gt?: ...;
                                      $gte?: ...;
                                      $in?: ...;
                                      $lt?: ...;
                                      $lte?: ...;
                                      $neq?: ...;
                                  };
                                  processDefinitionId?: | { __brand: ...; readonly [key: ...]: ... }
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                                  processDefinitionKey?: | { __brand: ...; readonly [key: ...]: ... }
                                  | { $eq?: ...; $exists?: ...; $in?: ...; $neq?: ...; $notIn?: ... };
                                  processInstanceKey?:
                                      | { __brand: ...; readonly [key: ...]: ... }
                                      | { $eq?: ...; $exists?: ...; $in?: ...; $neq?: ...; $notIn?: ... };
                                  processInstanceVariables?: (...)[];
                                  state?:
                                      | UserTaskStateEnum
                                      | { $eq?: ...; $exists?: ...; $in?: ...; $like?: ...; $neq?: ... };
                                  tags?: (...)[];
                                  tenantId?:
                                      | string
                                      | {
                                          $eq?: ...;
                                          $exists?: ...;
                                          $in?: ...;
                                          $like?: ...;
                                          $neq?: ...;
                                          $notIn?: ...;
                                      };
                                  userTaskKey?: { __brand: ...; readonly [key: ...]: ... };
                              }[];
                              assignee?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              candidateGroup?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              candidateUser?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              completionDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              creationDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              dueDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              elementId?: { __brand: "ElementId"; readonly [key: number]: string };
                              elementInstanceKey?: {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              };
                              followUpDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              isSuspended?: boolean;
                              localVariables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[];
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              priority?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionId?: | {
                                  __brand: "ProcessDefinitionId";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionId";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: {
                                      __brand: "ProcessDefinitionId";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceVariables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: ...;
                                      $exists?: ...;
                                      $in?: ...;
                                      $like?: ...;
                                      $neq?: ...;
                                      $notIn?: ...;
                                  };
                              }[];
                              state?: | UserTaskStateEnum
                              | {
                                  $eq?: UserTaskStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: UserTaskStateEnum[];
                                  $like?: string;
                                  $neq?: UserTaskStateEnum | undefined;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              userTaskKey?: {
                                  __brand: "UserTaskKey";
                                  readonly [key: number]: string;
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "priority"
                              | "businessId"
                              | "name"
                              | "creationDate"
                              | "completionDate"
                              | "followUpDate"
                              | "dueDate";
                              order?: SortOrderEnum;
                          }[];
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              assignee: ...;
                                              businessId: ...;
                                              candidateGroups: ...;
                                              candidateUsers: ...;
                                              completionDate: ...;
                                              creationDate: ...;
                                              customHeaders: ...;
                                              dueDate: ...;
                                              elementId: ...;
                                              elementInstanceKey: ...;
                                              externalFormReference: ...;
                                              followUpDate: ...;
                                              formKey: ...;
                                              isSuspended: ...;
                                              name: ...;
                                              priority: ...;
                                              processDefinitionId: ...;
                                              processDefinitionKey: ...;
                                              processDefinitionVersion: ...;
                                              processInstanceKey: ...;
                                              processName: ...;
                                              rootProcessInstanceKey: ...;
                                              state: ...;
                                              tags: ...;
                                              tenantId: ...;
                                              userTaskKey: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          assignee: string
                          | null;
                          businessId:
                              | { __brand: "BusinessId"; readonly [key: number]: string }
                              | null;
                          candidateGroups: string[];
                          candidateUsers: string[];
                          completionDate: string | null;
                          creationDate: string;
                          customHeaders: { [key: string]: string };
                          dueDate: string | null;
                          elementId: string;
                          elementInstanceKey: string;
                          externalFormReference: string | null;
                          followUpDate: string | null;
                          formKey: { __brand: "FormKey"; readonly [key: number]: string } | null;
                          isSuspended: boolean;
                          name: string | null;
                          priority: number;
                          processDefinitionId: string;
                          processDefinitionKey: string;
                          processDefinitionVersion: number;
                          processInstanceKey: string;
                          processName: string | null;
                          rootProcessInstanceKey:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | null;
                          state: UserTaskStateEnum;
                          tags: string[];
                          tenantId: string;
                          userTaskKey: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchUserTaskVariables(
                  ...a: [
                      input: {
                          filter?: {
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "tenantId"
                              | "processInstanceKey"
                              | "name"
                              | "value"
                              | "variableKey"
                              | "scopeKey";
                              order?: SortOrderEnum;
                          }[];
                          truncateValues?: boolean;
                          userTaskKey: string;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              isTruncated: ...;
                                              name: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              scopeKey: ...;
                                              tenantId: ...;
                                              value: ...;
                                              variableKey: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          isTruncated: boolean;
                          name: string;
                          processInstanceKey: string;
                          rootProcessInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          scopeKey: string;
                          tenantId: string;
                          value: string;
                          variableKey: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchVariables(
                  ...a: [
                      input: {
                          filter?: {
                              isTruncated?: boolean;
                              name?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              scopeKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | { __brand: "ElementInstanceKey"; readonly [key: number]: string }
                              | {
                                  $eq?:
                                      | {
                                          __brand: "ProcessInstanceKey";
                                          readonly [key: number]: string;
                                      }
                                      | { __brand: "ElementInstanceKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?:
                                      | {
                                          __brand: "ProcessInstanceKey";
                                          readonly [key: number]: string;
                                      }
                                      | { __brand: "ElementInstanceKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                              tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                              value?:
                                  | string
                                  | {
                                      $eq?: string;
                                      $exists?: boolean;
                                      $in?: string[];
                                      $like?: string;
                                      $neq?: string;
                                      $notIn?: string[];
                                  };
                              variableKey?: | {
                                  __brand: "VariableKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: { __brand: "VariableKey"; readonly [key: number]: string };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: { __brand: "VariableKey"; readonly [key: number]: string };
                                  $notIn?: string[];
                              };
                          };
                          page?: | { from?: number; limit?: number }
                          | {
                              after?: { __brand: "EndCursor"; readonly [key: number]: string };
                              limit?: number;
                          }
                          | { limit?: number }
                          | {
                              before?: { __brand: "StartCursor"; readonly [key: number]: string };
                              limit?: number;
                          };
                          sort?: {
                              field: | "tenantId"
                              | "processInstanceKey"
                              | "name"
                              | "value"
                              | "variableKey"
                              | "scopeKey";
                              order?: SortOrderEnum;
                          }[];
                          truncateValues?: boolean;
                      },
                      consistencyManagement: {
                          consistency: {
                              abortSignal?: {};
                              onAttempt?: (
                                  ...a: [
                                      info: {
                                          attempt: number;
                                          elapsedMs: number;
                                          nextDelayMs?: number;
                                          predicateResult?: boolean;
                                          remainingMs: number;
                                          status?: number;
                                      },
                                  ],
                              ) => void;
                              onComplete?: (
                                  ...a: [info: { attempts: number; elapsedMs: number }],
                              ) => void;
                              pollIntervalMs?: number;
                              predicate?: (
                                  ...a: [
                                      result: {
                                          items: {
                                              isTruncated: ...;
                                              name: ...;
                                              processInstanceKey: ...;
                                              rootProcessInstanceKey: ...;
                                              scopeKey: ...;
                                              tenantId: ...;
                                              value: ...;
                                              variableKey: ...;
                                          }[];
                                          page: {
                                              endCursor: (...)
                                              | (...);
                                              hasMoreTotalItems: boolean;
                                              startCursor: (...) | (...);
                                              totalItems: number;
                                          };
                                      },
                                  ],
                              ) => boolean
                              | Promise<boolean>;
                              trace?: boolean;
                              waitUpToMs: number;
                          };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      items: {
                          isTruncated: boolean;
                          name: string;
                          processInstanceKey: string;
                          rootProcessInstanceKey: | {
                              __brand: "ProcessInstanceKey";
                              readonly [key: number]: string;
                          }
                          | null;
                          scopeKey: string;
                          tenantId: string;
                          value: string;
                          variableKey: string;
                      }[];
                      page: {
                          endCursor: | {
                              __brand: "EndCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          hasMoreTotalItems: boolean;
                          startCursor: | {
                              __brand: "StartCursor";
                              readonly [key: number]: string;
                          }
                          | null;
                          totalItems: number;
                      };
                  },
              >;
              searchVariablesAsDto(
                  ...a: [
                      schema: {},
                      options: {
                          consistency?: { pollIntervalMs?: number; waitUpToMs: number };
                          pageSize?: number;
                          processInstanceKey: string;
                          scopeKey?:
                              | { __brand: "ProcessInstanceKey"; readonly [key: number]: string }
                              | { __brand: "ElementInstanceKey"; readonly [key: number]: string };
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                      },
                  ],
              ): CancelablePromise<
                  {
                      raw: { readonly [key: string]: unknown };
                      get(...a: [variableName: string]): unknown;
                      has(...a: [variableName: string]): boolean;
                      validate(...a: []): { [key: string]: unknown };
                  },
              >;
              stopAllWorkers(...a: []): void;
              suspendBatchOperation(
                  ...a: [
                      input: { batchOperationKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              suspendProcessDefinitions(
                  ...a: [
                      input: | {
                          includeProcessInstances?: boolean;
                          processDefinitionKey: string;
                      }
                      | {
                          includeProcessInstances?: boolean;
                          processDefinitionId: string;
                          processDefinitionVersion?: number;
                          tenantId?: { __brand: "TenantId"; readonly [key: number]: string };
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: | {
                          __brand: "BatchOperationKey";
                          readonly [key: number]: string;
                      }
                      | null;
                      processDefinitions: {
                          outcome: "SUSPENDED"
                          | "DRAINING"
                          | "ALREADY_SUSPENDED";
                          processDefinitionKey: string;
                          processDefinitionVersion: number;
                      }[];
                  },
              >;
              suspendProcessInstance(
                  ...a: [
                      input: { operationReference?: number; processInstanceKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              suspendProcessInstancesBatchOperation(
                  ...a: [
                      input: {
                          filter: {
                              $or?: {
                                  batchOperationId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  batchOperationKey?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  businessId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  elementInstanceState?: | ElementInstanceStateEnum
                                  | {
                                      $eq?: ElementInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ElementInstanceStateEnum | undefined;
                                  };
                                  endDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  errorMessage?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  hasElementInstanceIncident?: boolean;
                                  hasIncident?: boolean;
                                  hasRetriesLeft?: boolean;
                                  incidentErrorHashCode?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  parentElementInstanceKey?: | {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  parentProcessInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionKey?: | {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionName?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processDefinitionVersion?: | number
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  processDefinitionVersionTag?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  processInstanceKey?: | {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  }
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  startDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  state?: | ProcessInstanceStateEnum
                                  | {
                                      $eq?: ProcessInstanceStateEnum | undefined;
                                      $exists?: (...)
                                      | (...)
                                      | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: ProcessInstanceStateEnum | undefined;
                                  };
                                  suspendedDate?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $gt?: (...) | (...);
                                      $gte?: (...) | (...);
                                      $in?: (...) | (...);
                                      $lt?: (...) | (...);
                                      $lte?: (...) | (...);
                                      $neq?: (...) | (...);
                                  };
                                  tags?: string[];
                                  tenantId?: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                                  variables?: { name: ...; value: ... }[];
                              }[];
                              batchOperationId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              batchOperationKey?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              businessId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceState?: | ElementInstanceStateEnum
                              | {
                                  $eq?: ElementInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ElementInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ElementInstanceStateEnum | undefined;
                              };
                              endDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasElementInstanceIncident?: boolean;
                              hasIncident?: boolean;
                              hasRetriesLeft?: boolean;
                              incidentErrorHashCode?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              parentElementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              parentProcessInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processDefinitionName?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionVersion?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionVersionTag?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              startDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              state?: | ProcessInstanceStateEnum
                              | {
                                  $eq?: ProcessInstanceStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: ProcessInstanceStateEnum[];
                                  $like?: string;
                                  $neq?: ProcessInstanceStateEnum | undefined;
                              };
                              suspendedDate?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              tags?: string[];
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              variables?: {
                                  name: string;
                                  value: | string
                                  | {
                                      $eq?: (...)
                                      | (...);
                                      $exists?: (...) | (...) | (...);
                                      $in?: (...) | (...);
                                      $like?: (...) | (...);
                                      $neq?: (...) | (...);
                                      $notIn?: (...) | (...);
                                  };
                              }[];
                          };
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              syncRuntimeBackupState(
                  ...a: [
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupStates: {
                          checkpointId: number;
                          checkpointPosition: number;
                          checkpointTimestamp: string;
                          checkpointType: BackupType;
                          firstLogPosition: number;
                          partitionId: number
                          | null;
                      }[];
                      checkpointStates: {
                          checkpointId: number;
                          checkpointPosition: number;
                          checkpointTimestamp: string;
                          checkpointType: CheckpointType;
                          partitionId: number;
                      }[];
                      ranges: {
                          end: | {
                              checkpointId: number;
                              checkpointPosition: number;
                              checkpointTimestamp: string;
                              checkpointType: BackupType;
                              firstLogPosition: number;
                              partitionId: number
                              | null;
                          }
                          | null;
                          partitionId: number;
                          start: | {
                              checkpointId: number;
                              checkpointPosition: number;
                              checkpointTimestamp: string;
                              checkpointType: BackupType;
                              firstLogPosition: number;
                              partitionId: number
                              | null;
                          }
                          | null;
                      }[];
                  },
              >;
              syncRuntimeBackupStateAsClusterAdmin(
                  ...a: [
                      input: { physicalTenantId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      physicalTenants: {
                          physicalTenantId: string;
                          state: {
                              backupStates: {
                                  checkpointId: number;
                                  checkpointPosition: number;
                                  checkpointTimestamp: string;
                                  checkpointType: BackupType;
                                  firstLogPosition: number;
                                  partitionId: number
                                  | null;
                              }[];
                              checkpointStates: {
                                  checkpointId: number;
                                  checkpointPosition: number;
                                  checkpointTimestamp: string;
                                  checkpointType: CheckpointType;
                                  partitionId: number;
                              }[];
                              ranges: {
                                  end: | {
                                      checkpointId: ...;
                                      checkpointPosition: ...;
                                      checkpointTimestamp: ...;
                                      checkpointType: ...;
                                      firstLogPosition: ...;
                                      partitionId: ...;
                                  }
                                  | null;
                                  partitionId: number;
                                  start: | {
                                      checkpointId: ...;
                                      checkpointPosition: ...;
                                      checkpointTimestamp: ...;
                                      checkpointType: ...;
                                      firstLogPosition: ...;
                                      partitionId: ...;
                                  }
                                  | null;
                              }[];
                          };
                      }[];
                  },
              >;
              takeHistoryBackup(
                  ...a: [
                      input: { backupId: number },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ backupId: number; scheduledSnapshots: string[] }>;
              takeHistoryBackupAsClusterAdmin(
                  ...a: [
                      input: { backupId: number; physicalTenantId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      backupId: number;
                      physicalTenants: {
                          physicalTenantId: string;
                          scheduledSnapshots: string[];
                      }[];
                  },
              >;
              takeRuntimeBackup(
                  ...a: [
                      input: { backupId?: number
                      | null },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<{ backupId: number }>;
              takeRuntimeBackupAsClusterAdmin(
                  ...a: [
                      input: { backupId?: number
                      | null; physicalTenantId?: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      physicalTenants: {
                          backupId: number
                          | null;
                          outcome: ClusterRuntimeBackupTakeOutcome;
                          physicalTenantId: string;
                          reason: string | null;
                      }[];
                  },
              >;
              throwJobError(
                  ...a: [
                      input: {
                          errorCode: string;
                          errorMessage?: string
                          | null;
                          jobKey: string;
                          jobLeaseToken?:
                              | { __brand: "JobLeaseToken"; readonly [key: number]: string }
                              | null;
                          variables?: { [key: string]: unknown } | null;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              triggerClusterRebalance(
                  ...a: [
                      input: {
                          dryRun?: boolean;
                          leaderWaitTimeout?: string;
                          maxTransferAttempts?: number;
                          replicationLagThreshold?: number;
                          replicationTimeout?: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      lastCompletedRebalance: | {
                          finishedAt: string;
                          partitions: {
                              currentLeader: string
                              | null;
                              desiredLeader: string;
                              partitionId: number;
                              physicalTenantId: string;
                              progress: "COMPLETED" | "PENDING" | "TRANSFERRING";
                              result:
                                  | "CANCELLED"
                                  | "TRANSFERRED"
                                  | "ALREADY_LEADER"
                                  | "NOT_MEMBER"
                                  | "NOT_REPLICATING"
                                  | "UNREACHABLE"
                                  | "NOT_COORDINATOR"
                                  | "STALE_CONFIGURATION"
                                  | "TRANSFER_IN_PROGRESS"
                                  | "LAG_TOO_HIGH"
                                  | "LEADER_INITIALIZING"
                                  | "CONFIGURATION_CHANGE_IN_PROGRESS"
                                  | "PAUSE_FAILED"
                                  | "REPLICATION_TIMED_OUT"
                                  | "TIMEOUT_NOW_EXHAUSTED"
                                  | "LEADER_CHANGED"
                                  | "NO_LEADER"
                                  | "NO_RESPONSE"
                                  | "PHYSICAL_TENANT_DISABLED"
                                  | "PHYSICAL_TENANT_RECOVERING";
                          }[];
                          rebalanceId: number;
                          result: "COMPLETED"
                          | "FAILED"
                          | "CANCELLED";
                          startedAt: string;
                      }
                      | null;
                      partitions: {
                          currentLeader: string
                          | null;
                          desiredLeader: string;
                          partitionId: number;
                          physicalTenantId: string;
                          state: "BALANCED" | "UNBALANCED" | "TRANSFERRING";
                      }[];
                      runningRebalance: | {
                          cancelRequested: boolean;
                          dryRun: boolean;
                          partitions: {
                              currentLeader: string
                              | null;
                              desiredLeader: string;
                              partitionId: number;
                              physicalTenantId: string;
                              progress: "COMPLETED" | "PENDING" | "TRANSFERRING";
                              result:
                                  | "CANCELLED"
                                  | "TRANSFERRED"
                                  | "ALREADY_LEADER"
                                  | "NOT_MEMBER"
                                  | "NOT_REPLICATING"
                                  | "UNREACHABLE"
                                  | "NOT_COORDINATOR"
                                  | "STALE_CONFIGURATION"
                                  | "TRANSFER_IN_PROGRESS"
                                  | "LAG_TOO_HIGH"
                                  | "LEADER_INITIALIZING"
                                  | "CONFIGURATION_CHANGE_IN_PROGRESS"
                                  | "PAUSE_FAILED"
                                  | "REPLICATION_TIMED_OUT"
                                  | "TIMEOUT_NOW_EXHAUSTED"
                                  | "LEADER_CHANGED"
                                  | "NO_LEADER"
                                  | "NO_RESPONSE"
                                  | "PHYSICAL_TENANT_DISABLED"
                                  | "PHYSICAL_TENANT_RECOVERING";
                          }[];
                          rebalanceId: number;
                          startedAt: string;
                      }
                      | null;
                      state: "BALANCED"
                      | "BALANCING"
                      | "UNBALANCED";
                  },
              >;
              unassignClientFromGroup(
                  ...a: [
                      input: { clientId: string; groupId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignClientFromTenant(
                  ...a: [
                      input: { clientId: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignGroupFromTenant(
                  ...a: [
                      input: { groupId: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignMappingRuleFromGroup(
                  ...a: [
                      input: { groupId: string; mappingRuleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignMappingRuleFromTenant(
                  ...a: [
                      input: { mappingRuleId: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignRoleFromClient(
                  ...a: [
                      input: { clientId: string; roleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignRoleFromGroup(
                  ...a: [
                      input: { groupId: string; roleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignRoleFromMappingRule(
                  ...a: [
                      input: { mappingRuleId: string; roleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignRoleFromTenant(
                  ...a: [
                      input: { roleId: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignRoleFromUser(
                  ...a: [
                      input: { roleId: string; username: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignUserFromGroup(
                  ...a: [
                      input: { groupId: string; username: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignUserFromTenant(
                  ...a: [
                      input: { tenantId: string; username: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              unassignUserTask(
                  ...a: [
                      input: { userTaskKey: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              updateAgentInstance(
                  ...a: [
                      input: {
                          agentInstanceKey: string;
                          elementInstanceKey: string;
                          history?: | {
                              content: (
                                  | { contentType: "TEXT"; text: string }
                                  | {
                                      contentType: "DOCUMENT";
                                      documentReference: {
                                          "camunda.document.type": ...;
                                          contentHash: ...;
                                          documentId: ...;
                                          metadata: ...;
                                          storeId: ...;
                                      };
                                  }
                                  | { contentType: "OBJECT"; object: unknown }
                              )[];
                              historyItemId: string;
                              limits?: {
                                  maxModelCalls: number;
                                  maxTokens: number;
                                  maxToolCalls: number;
                              };
                              loopIteration: number;
                              metrics?: | {
                                  cacheCreationTokenCount?: number
                                  | null;
                                  cacheReadTokenCount?: number | null;
                                  durationMs?: number | null;
                                  inputTokens?: number | null;
                                  outputTokens?: number | null;
                                  reasoningTokenCount?: number | null;
                              }
                              | null;
                              model?: string;
                              producedAt: string;
                              provider?: string;
                              role: AgentInstanceHistoryRoleEnum;
                              systemPrompt?: | (
                                  | { contentType: ...; text: ... }
                                  | { contentType: ...; documentReference: ... }
                                  | { contentType: ...; object: ... }
                              )[]
                              | null;
                              toolCalls?:
                                  | {
                                      arguments: (...)
                                      | (...);
                                      elementId: (...) | (...);
                                      toolCallId: string;
                                      toolName: string;
                                  }[]
                                  | null;
                              tools?: | {
                                  description: (...)
                                  | (...);
                                  elementId: (...) | (...);
                                  name: string;
                              }[]
                              | null;
                          }[]
                          | null;
                          jobKey: string;
                          jobLeaseToken: string;
                          status?: AgentInstanceUpdateStatusEnum;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      createdHistory: {
                          historyItemId: string;
                          historyItemKey: string;
                          isDuplicate: boolean;
                      }[];
                  },
              >;
              updateAuthorization(
                  ...a: [
                      input: | {
                          authorizationKey: string;
                          ownerId: string;
                          ownerType: OwnerTypeEnum;
                          permissionTypes: PermissionTypeEnum[];
                          resourceId: string;
                          resourceType: ResourceTypeEnum;
                      }
                      | {
                          authorizationKey: string;
                          ownerId: string;
                          ownerType: OwnerTypeEnum;
                          permissionTypes: PermissionTypeEnum[];
                          resourcePropertyName: string;
                          resourceType: ResourceTypeEnum;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              updateGlobalClusterVariable(
                  ...a: [
                      input: {
                          metadata?: { [key: string]: string
                          | number };
                          name: string;
                          value: unknown;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      kind: ClusterVariableKindEnum;
                      metadata: { [key: string]: string
                      | number };
                      name: string;
                      scope: ClusterVariableScopeEnum;
                      tenantId: string | null;
                      value: string;
                  },
              >;
              updateGlobalTaskListener(
                  ...a: [
                      input: {
                          afterNonGlobal?: boolean;
                          eventTypes?: GlobalTaskListenerEventTypeEnum[];
                          id: string;
                          priority?: number;
                          retries?: number;
                          type?: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      afterNonGlobal?: boolean;
                      eventTypes: GlobalTaskListenerEventTypeEnum[];
                      id: string;
                      priority?: number;
                      retries?: number;
                      source: GlobalListenerSourceEnum;
                      type?: string;
                  },
              >;
              updateGroup(
                  ...a: [
                      input: { description?: string; groupId: string; name: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { description: string
                  | null; groupId: string; name: string },
              >;
              updateJob(
                  ...a: [
                      input: {
                          changeset: {
                              priority?: number
                              | null;
                              retries?: number | null;
                              timeout?: number | null;
                          };
                          jobKey: string;
                          jobLeaseToken?: | {
                              __brand: "JobLeaseToken";
                              readonly [key: number]: string;
                          }
                          | null;
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              updateJobsBatchOperation(
                  ...a: [
                      input: {
                          changeset: {
                              priority?: number
                              | null;
                              retries?: number | null;
                              timeout?: number | null;
                          };
                          filter: {
                              creationTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              deadline?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              }
                              | null;
                              deniedReason?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              elementInstanceKey?: | {
                                  __brand: "ElementInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ElementInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              endTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              errorCode?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              errorMessage?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              hasFailedWithRetriesLeft?: boolean;
                              isDenied?: boolean
                              | null;
                              jobKey?:
                                  | { __brand: "JobKey"; readonly [key: number]: string }
                                  | {
                                      $eq?: { __brand: "JobKey"; readonly [key: number]: string };
                                      $exists?: boolean;
                                      $in?: string[];
                                      $neq?: { __brand: "JobKey"; readonly [key: number]: string };
                                      $notIn?: string[];
                                  };
                              kind?: | JobKindEnum
                              | {
                                  $eq?: JobKindEnum | undefined;
                                  $exists?: boolean;
                                  $in?: JobKindEnum[];
                                  $like?: string;
                                  $neq?: JobKindEnum | undefined;
                              };
                              lastUpdateTime?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $gt?: string;
                                  $gte?: string;
                                  $in?: string[];
                                  $lt?: string;
                                  $lte?: string;
                                  $neq?: string;
                              };
                              listenerEventType?: | JobListenerEventTypeEnum
                              | {
                                  $eq?: JobListenerEventTypeEnum | undefined;
                                  $exists?: boolean;
                                  $in?: JobListenerEventTypeEnum[];
                                  $like?: string;
                                  $neq?: JobListenerEventTypeEnum | undefined;
                              };
                              priority?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              processDefinitionId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              processDefinitionKey?: | {
                                  __brand: "ProcessDefinitionKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessDefinitionKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              processInstanceKey?: | {
                                  __brand: "ProcessInstanceKey";
                                  readonly [key: number]: string;
                              }
                              | {
                                  $eq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $exists?: boolean;
                                  $in?: string[];
                                  $neq?: {
                                      __brand: "ProcessInstanceKey";
                                      readonly [key: number]: string;
                                  };
                                  $notIn?: string[];
                              };
                              retries?: | number
                              | {
                                  $eq?: number;
                                  $exists?: boolean;
                                  $gt?: number;
                                  $gte?: number;
                                  $in?: number[];
                                  $lt?: number;
                                  $lte?: number;
                                  $neq?: number;
                              };
                              state?: | JobStateEnum
                              | {
                                  $eq?: JobStateEnum | undefined;
                                  $exists?: boolean;
                                  $in?: JobStateEnum[];
                                  $like?: string;
                                  $neq?: JobStateEnum | undefined;
                              };
                              tenantId?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              type?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                              worker?: | string
                              | {
                                  $eq?: string;
                                  $exists?: boolean;
                                  $in?: string[];
                                  $like?: string;
                                  $neq?: string;
                                  $notIn?: string[];
                              };
                          };
                          operationReference?: number;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      batchOperationKey: string;
                      batchOperationType: BatchOperationTypeEnum;
                  },
              >;
              updateMappingRule(
                  ...a: [
                      input: {
                          claimName: string;
                          claimValue: string;
                          mappingRuleId: string;
                          name: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      claimName: string;
                      claimValue: string;
                      mappingRuleId: string;
                      name: string;
                  },
              >;
              updateRole(
                  ...a: [
                      input: { description?: string; name: string; roleId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { description: string
                  | null; name: string; roleId: string },
              >;
              updateTenant(
                  ...a: [
                      input: { description?: string; name: string; tenantId: string },
                      options?: {
                          retry?:
                              | false
                              | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { description: string
                  | null; name: string; tenantId: string },
              >;
              updateTenantClusterVariable(
                  ...a: [
                      input: {
                          metadata?: { [key: string]: string
                          | number };
                          name: string;
                          tenantId: string;
                          value: unknown;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  {
                      kind: ClusterVariableKindEnum;
                      metadata: { [key: string]: string
                      | number };
                      name: string;
                      scope: ClusterVariableScopeEnum;
                      tenantId: string | null;
                      value: string;
                  },
              >;
              updateUser(
                  ...a: [
                      input: {
                          email?: string;
                          name?: string;
                          password?: string;
                          username: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<
                  { email: string
                  | null; name: string | null; username: string },
              >;
              updateUserTask(
                  ...a: [
                      input: {
                          action?: string
                          | null;
                          changeset?:
                              | {
                                  candidateGroups?: string[]
                                  | null;
                                  candidateUsers?: string[] | null;
                                  dueDate?: ClearableDateTime;
                                  followUpDate?: ClearableDateTime;
                                  priority?: number | null;
                                  [key: string]: unknown;
                              }
                              | null;
                          userTaskKey: string;
                      },
                      options?: {
                          retry?: | false
                          | { baseDelayMs?: number; maxAttempts?: number; maxDelayMs?: number };
                      },
                  ],
              ): CancelablePromise<void>;
              withCorrelation(
                  ...a: [id: string, fn: (...a: []) => unknown],
              ): Promise<unknown>;
          },
      >