@bpmnkit/api 0.0.8

package/dist/generated/resources.d.ts

@@ -0,0 +1,1519 @@
+import type { CamundaClientInput } from "../runtime/types.js";
+import { CamundaBaseClient } from "../runtime/client.js";
+import { ResourceBase } from "../runtime/client.js";
+import type * as Types from "./types.js";
+export declare class AuditLogResource extends ResourceBase {
+    /**
+     * Search audit logs
+     *
+     * Search for audit logs based on given criteria.
+     * @see POST /audit-logs/search
+     */
+    searchAuditLogs(body?: Types.AuditLogSearchQueryRequest): Promise<Types.AuditLogSearchQueryResult>;
+    /**
+     * Get audit log
+     *
+     * Get an audit log entry by auditLogKey.
+     * @see GET /audit-logs/{auditLogKey}
+     */
+    getAuditLog(auditLogKey: string): Promise<Types.AuditLogResult>;
+}
+export declare class AuthenticationResource extends ResourceBase {
+    /**
+     * Get current user
+     *
+     * Retrieves the current authenticated user.
+     * @see GET /authentication/me
+     */
+    getAuthentication(): Promise<Types.CamundaUserResult>;
+}
+export declare class AuthorizationResource extends ResourceBase {
+    /**
+     * Create authorization
+     *
+     * Create the authorization.
+     * @see POST /authorizations
+     */
+    createAuthorization(body: Types.AuthorizationRequest): Promise<Types.AuthorizationCreateResult>;
+    /**
+     * Search authorizations
+     *
+     * Search for authorizations based on given criteria.
+     * @see POST /authorizations/search
+     */
+    searchAuthorizations(body?: Types.AuthorizationSearchQuery): Promise<Types.AuthorizationSearchResult>;
+    /**
+     * Get authorization
+     *
+     * Get authorization by the given key.
+     * @see GET /authorizations/{authorizationKey}
+     */
+    getAuthorization(authorizationKey: string): Promise<Types.AuthorizationResult>;
+    /**
+     * Update authorization
+     *
+     * Update the authorization with the given key.
+     * @see PUT /authorizations/{authorizationKey}
+     */
+    updateAuthorization(authorizationKey: string, body: Types.AuthorizationRequest): Promise<void>;
+    /**
+     * Delete authorization
+     *
+     * Deletes the authorization with the given key.
+     * @see DELETE /authorizations/{authorizationKey}
+     */
+    deleteAuthorization(authorizationKey: string): Promise<void>;
+}
+export declare class BatchOperationResource extends ResourceBase {
+    /**
+     * Search batch operation items
+     *
+     * Search for batch operation items based on given criteria.
+     * @see POST /batch-operation-items/search
+     */
+    searchBatchOperationItems(body?: Types.BatchOperationItemSearchQuery): Promise<Types.BatchOperationItemSearchQueryResult>;
+    /**
+     * Search batch operations
+     *
+     * Search for batch operations based on given criteria.
+     * @see POST /batch-operations/search
+     */
+    searchBatchOperations(body?: Types.BatchOperationSearchQuery): Promise<Types.BatchOperationSearchQueryResult>;
+    /**
+     * Get batch operation
+     *
+     * Get batch operation by key.
+     * @see GET /batch-operations/{batchOperationKey}
+     */
+    getBatchOperation(batchOperationKey: string): Promise<Types.BatchOperationResponse>;
+    /**
+     * Cancel Batch operation
+     *
+     *  Cancels a running batch operation.
+     *  This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).
+     * @see POST /batch-operations/{batchOperationKey}/cancellation
+     */
+    cancelBatchOperation(batchOperationKey: string): Promise<void>;
+    /**
+     * Resume Batch operation
+     *
+     *  Resumes a suspended batch operation.
+     *  This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).
+     * @see POST /batch-operations/{batchOperationKey}/resumption
+     */
+    resumeBatchOperation(batchOperationKey: string): Promise<void>;
+    /**
+     * Suspend Batch operation
+     *
+     *  Suspends a running batch operation.
+     *  This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).
+     * @see POST /batch-operations/{batchOperationKey}/suspension
+     */
+    suspendBatchOperation(batchOperationKey: string): Promise<void>;
+}
+export declare class ClockResource extends ResourceBase {
+    /**
+     * Pin internal clock (alpha)
+     *
+     *  Set a precise, static time for the Zeebe engine's internal clock.
+     *  When the clock is pinned, it remains at the specified time and does not advance.
+     *  To change the time, the clock must be pinned again with a new timestamp.
+     * @see PUT /clock
+     */
+    pinClock(body: Types.ClockPinRequest): Promise<void>;
+    /**
+     * Reset internal clock (alpha)
+     *
+     *  Resets the Zeebe engine's internal clock to the current system time, enabling it to tick in real-time.
+     *  This operation is useful for returning the clock to
+     *  normal behavior after it has been pinned to a specific time.
+     * @see POST /clock/reset
+     */
+    resetClock(): Promise<void>;
+}
+export declare class ClusterVariableResource extends ResourceBase {
+    /**
+     * Create a global-scoped cluster variable
+     *
+     * Create a global-scoped cluster variable.
+     * @see POST /cluster-variables/global
+     */
+    createGlobalClusterVariable(body: Types.CreateClusterVariableRequest): Promise<Types.ClusterVariableResult>;
+    /**
+     * Get a global-scoped cluster variable
+     *
+     * Get a global-scoped cluster variable.
+     * @see GET /cluster-variables/global/{name}
+     */
+    getGlobalClusterVariable(name: string): Promise<Types.ClusterVariableResult>;
+    /**
+     * Update a global-scoped cluster variable
+     *
+     *  Updates the value of an existing global cluster variable.
+     *  The variable must exist, otherwise a 404 error is returned.
+     * @see PUT /cluster-variables/global/{name}
+     */
+    updateGlobalClusterVariable(name: string, body: Types.UpdateClusterVariableRequest): Promise<Types.ClusterVariableResult>;
+    /**
+     * Delete a global-scoped cluster variable
+     *
+     * Delete a global-scoped cluster variable.
+     * @see DELETE /cluster-variables/global/{name}
+     */
+    deleteGlobalClusterVariable(name: string): Promise<void>;
+    /**
+     *
+     * Search for cluster variables based on given criteria. By default, long variable values in the response are truncated.
+     * @see POST /cluster-variables/search
+     */
+    searchClusterVariables(body?: Types.ClusterVariableSearchQueryRequest, query?: {
+        truncateValues?: boolean;
+    }): Promise<Types.ClusterVariableSearchQueryResult>;
+    /**
+     * Create a tenant-scoped cluster variable
+     *
+     * Create a new cluster variable for the given tenant.
+     * @see POST /cluster-variables/tenants/{tenantId}
+     */
+    createTenantClusterVariable(tenantId: string, body: Types.CreateClusterVariableRequest): Promise<Types.ClusterVariableResult>;
+    /**
+     * Get a tenant-scoped cluster variable
+     *
+     * Get a tenant-scoped cluster variable.
+     * @see GET /cluster-variables/tenants/{tenantId}/{name}
+     */
+    getTenantClusterVariable(tenantId: string, name: string): Promise<Types.ClusterVariableResult>;
+    /**
+     * Update a tenant-scoped cluster variable
+     *
+     *  Updates the value of an existing tenant-scoped cluster variable.
+     *  The variable must exist, otherwise a 404 error is returned.
+     * @see PUT /cluster-variables/tenants/{tenantId}/{name}
+     */
+    updateTenantClusterVariable(tenantId: string, name: string, body: Types.UpdateClusterVariableRequest): Promise<Types.ClusterVariableResult>;
+    /**
+     * Delete a tenant-scoped cluster variable
+     *
+     * Delete a tenant-scoped cluster variable.
+     * @see DELETE /cluster-variables/tenants/{tenantId}/{name}
+     */
+    deleteTenantClusterVariable(tenantId: string, name: string): Promise<void>;
+}
+export declare class ConditionalResource extends ResourceBase {
+    /**
+     * Evaluate root level conditional start events
+     *
+     *  Evaluates root-level conditional start events for process definitions.
+     *  If the evaluation is successful, it will return the keys of all created process instances, along with their associated process definition key.
+     *  Multiple root-level conditional start events of the same process definition can trigger if their conditions evaluate to true.
+     * @see POST /conditionals/evaluation
+     */
+    evaluateConditionals(body: Types.ConditionalEvaluationInstruction): Promise<Types.EvaluateConditionalResult>;
+}
+export declare class MessageSubscriptionResource extends ResourceBase {
+    /**
+     * Search correlated message subscriptions
+     *
+     * Search correlated message subscriptions based on given criteria.
+     * @see POST /correlated-message-subscriptions/search
+     */
+    searchCorrelatedMessageSubscriptions(body?: Types.CorrelatedMessageSubscriptionSearchQuery): Promise<Types.CorrelatedMessageSubscriptionSearchQueryResult>;
+    /**
+     * Search message subscriptions
+     *
+     * Search for message subscriptions based on given criteria.
+     * @see POST /message-subscriptions/search
+     */
+    searchMessageSubscriptions(body?: Types.MessageSubscriptionSearchQuery): Promise<Types.MessageSubscriptionSearchQueryResult>;
+}
+export declare class DecisionDefinitionResource extends ResourceBase {
+    /**
+     * Evaluate decision
+     *
+     *  Evaluates a decision.
+     *  You specify the decision to evaluate either by using its unique key (as returned by
+     *  DeployResource), or using the decision ID. When using the decision ID, the latest deployed
+     * @see POST /decision-definitions/evaluation
+     */
+    evaluateDecision(body: Types.DecisionEvaluationInstruction): Promise<Types.EvaluateDecisionResult>;
+    /**
+     * Search decision definitions
+     *
+     * Search for decision definitions based on given criteria.
+     * @see POST /decision-definitions/search
+     */
+    searchDecisionDefinitions(body?: Types.DecisionDefinitionSearchQuery): Promise<Types.DecisionDefinitionSearchQueryResult>;
+    /**
+     * Get decision definition
+     *
+     * Returns a decision definition by key.
+     * @see GET /decision-definitions/{decisionDefinitionKey}
+     */
+    getDecisionDefinition(decisionDefinitionKey: string): Promise<Types.DecisionDefinitionResult>;
+    /**
+     * Get decision definition XML
+     *
+     * Returns decision definition as XML.
+     * @see GET /decision-definitions/{decisionDefinitionKey}/xml
+     */
+    getDecisionDefinitionXML(decisionDefinitionKey: string): Promise<void>;
+}
+export declare class DecisionInstanceResource extends ResourceBase {
+    /**
+     * Search decision instances
+     *
+     * Search for decision instances based on given criteria.
+     * @see POST /decision-instances/search
+     */
+    searchDecisionInstances(body?: Types.DecisionInstanceSearchQuery): Promise<Types.DecisionInstanceSearchQueryResult>;
+    /**
+     * Get decision instance
+     *
+     * Returns a decision instance.
+     * @see GET /decision-instances/{decisionEvaluationInstanceKey}
+     */
+    getDecisionInstance(decisionEvaluationInstanceKey: string): Promise<Types.DecisionInstanceGetQueryResult>;
+    /**
+     * Delete decision instance
+     *
+     * Delete all associated decision evaluations based on provided key.
+     * @see POST /decision-instances/{decisionInstanceKey}/deletion
+     */
+    deleteDecisionInstance(decisionInstanceKey: string, body?: Types.DeleteDecisionInstanceRequest): Promise<void>;
+    /**
+     * Delete decision instances (batch)
+     *
+     *  Delete multiple decision instances. This will delete the historic data from secondary storage.
+     *  This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).
+     * @see POST /decision-instances/deletion
+     */
+    deleteDecisionInstancesBatchOperation(body: Types.DecisionInstanceDeletionBatchOperationRequest): Promise<Types.BatchOperationCreatedResult>;
+}
+export declare class DecisionRequirementsResource extends ResourceBase {
+    /**
+     * Search decision requirements
+     *
+     * Search for decision requirements based on given criteria.
+     * @see POST /decision-requirements/search
+     */
+    searchDecisionRequirements(body?: Types.DecisionRequirementsSearchQuery): Promise<Types.DecisionRequirementsSearchQueryResult>;
+    /**
+     * Get decision requirements
+     *
+     * Returns Decision Requirements as JSON.
+     * @see GET /decision-requirements/{decisionRequirementsKey}
+     */
+    getDecisionRequirements(decisionRequirementsKey: string): Promise<Types.DecisionRequirementsResult>;
+    /**
+     * Get decision requirements XML
+     *
+     * Returns decision requirements as XML.
+     * @see GET /decision-requirements/{decisionRequirementsKey}/xml
+     */
+    getDecisionRequirementsXML(decisionRequirementsKey: string): Promise<void>;
+}
+export declare class ResourceResource extends ResourceBase {
+    /**
+     * Deploy resources
+     *
+     *  Deploys one or more resources (e.g. processes, decision models, or forms).
+     *  This is an atomic call, i.e. either all resources are deployed or none of them are.
+     * @see POST /deployments
+     */
+    createDeployment(): Promise<Types.DeploymentResult>;
+    /**
+     * Get resource
+     *
+     *  Returns a deployed resource.
+     *  :::info
+     *  Currently, this endpoint only supports RPA resources.
+     * @see GET /resources/{resourceKey}
+     */
+    getResource(resourceKey: string): Promise<Types.ResourceResult>;
+    /**
+     * Get resource content
+     *
+     *  Returns the content of a deployed resource.
+     *  :::info
+     *  Currently, this endpoint only supports RPA resources.
+     * @see GET /resources/{resourceKey}/content
+     */
+    getResourceContent(resourceKey: string): Promise<string>;
+    /**
+     * Delete resource
+     *
+     *  Deletes a deployed resource. This can be a process definition, decision requirements
+     *  definition, or form definition deployed using the deploy resources endpoint. Specify the
+     *  resource you want to delete in the `resourceKey` parameter.
+     * @see POST /resources/{resourceKey}/deletion
+     */
+    deleteResource(resourceKey: string, body?: Types.DeleteResourceRequest): Promise<Types.DeleteResourceResponse>;
+}
+export declare class DocumentResource extends ResourceBase {
+    /**
+     * Upload document
+     *
+     *  Upload a document to the Camunda 8 cluster.
+     *
+     *  Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)
+     * @see POST /documents
+     */
+    createDocument(query?: {
+        storeId?: string;
+        documentId?: Types.DocumentId;
+    }): Promise<Types.DocumentReference>;
+    /**
+     * Upload multiple documents
+     *
+     *  Upload multiple documents to the Camunda 8 cluster.
+     *
+     *  The caller must provide a file name for each document, which will be used in case of a multi-status response
+     * @see POST /documents/batch
+     */
+    createDocuments(query?: {
+        storeId?: string;
+    }): Promise<Types.DocumentCreationBatchResponse>;
+    /**
+     * Download document
+     *
+     *  Download a document from the Camunda 8 cluster.
+     *
+     *  Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)
+     * @see GET /documents/{documentId}
+     */
+    getDocument(documentId: string, query?: {
+        storeId?: string;
+        contentHash?: string;
+    }): Promise<void>;
+    /**
+     * Delete document
+     *
+     *  Delete a document from the Camunda 8 cluster.
+     *
+     *  Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)
+     * @see DELETE /documents/{documentId}
+     */
+    deleteDocument(documentId: string, query?: {
+        storeId?: string;
+    }): Promise<void>;
+    /**
+     * Create document link
+     *
+     *  Create a link to a document in the Camunda 8 cluster.
+     *
+     *  Note that this is currently supported for document stores of type: AWS, GCP
+     * @see POST /documents/{documentId}/links
+     */
+    createDocumentLink(documentId: string, body?: Types.DocumentLinkRequest, query?: {
+        storeId?: string;
+        contentHash?: string;
+    }): Promise<Types.DocumentLink>;
+}
+export declare class AdHocSubProcessResource extends ResourceBase {
+    /**
+     * Activate activities within an ad-hoc sub-process
+     *
+     *  Activates selected activities within an ad-hoc sub-process identified by element ID.
+     *  The provided element IDs must exist within the ad-hoc sub-process instance identified by the
+     *  provided adHocSubProcessInstanceKey.
+     * @see POST /element-instances/ad-hoc-activities/{adHocSubProcessInstanceKey}/activation
+     */
+    activateAdHocSubProcessActivities(adHocSubProcessInstanceKey: string, body: Types.AdHocSubProcessActivateActivitiesInstruction): Promise<void>;
+}
+export declare class ElementInstanceResource extends ResourceBase {
+    /**
+     * Search element instances
+     *
+     * Search for element instances based on given criteria.
+     * @see POST /element-instances/search
+     */
+    searchElementInstances(body?: Types.ElementInstanceSearchQuery): Promise<Types.ElementInstanceSearchQueryResult>;
+    /**
+     * Get element instance
+     *
+     * Returns element instance as JSON.
+     * @see GET /element-instances/{elementInstanceKey}
+     */
+    getElementInstance(elementInstanceKey: string): Promise<Types.ElementInstanceResult>;
+    /**
+     * Search for incidents of a specific element instance
+     *
+     *  Search for incidents caused by the specified element instance, including incidents of any child instances created from this element instance.
+     *
+     *  Although the `elementInstanceKey` is provided as a path parameter to indicate the root element instance,
+     * @see POST /element-instances/{elementInstanceKey}/incidents/search
+     */
+    searchElementInstanceIncidents(elementInstanceKey: string, body: Types.IncidentSearchQuery): Promise<Types.IncidentSearchQueryResult>;
+    /**
+     * Update element instance variables
+     *
+     *  Updates all the variables of a particular scope (for example, process instance, element instance) with the given variable data.
+     *  Specify the element instance in the `elementInstanceKey` parameter.
+     * @see PUT /element-instances/{elementInstanceKey}/variables
+     */
+    createElementInstanceVariables(elementInstanceKey: string, body: Types.SetVariableRequest): Promise<void>;
+}
+export declare class ExpressionResource extends ResourceBase {
+    /**
+     * Evaluate an expression
+     *
+     * Evaluates a FEEL expression and returns the result. Supports references to tenant scoped cluster variables when a tenant ID is provided.
+     * @see POST /expression/evaluation
+     */
+    evaluateExpression(body: Types.ExpressionEvaluationRequest): Promise<Types.ExpressionEvaluationResult>;
+}
+export declare class GlobalListenerResource extends ResourceBase {
+    /**
+     * Create global user task listener
+     *
+     * Create a new global user task listener.
+     * @see POST /global-task-listeners
+     */
+    createGlobalTaskListener(body: Types.CreateGlobalTaskListenerRequest): Promise<Types.GlobalTaskListenerResult>;
+    /**
+     * Get global user task listener
+     *
+     * Get a global user task listener by its id.
+     * @see GET /global-task-listeners/{id}
+     */
+    getGlobalTaskListener(id: string): Promise<Types.GlobalTaskListenerResult>;
+    /**
+     * Update global user task listener
+     *
+     * Updates a global user task listener.
+     * @see PUT /global-task-listeners/{id}
+     */
+    updateGlobalTaskListener(id: string, body: Types.UpdateGlobalTaskListenerRequest): Promise<Types.GlobalTaskListenerResult>;
+    /**
+     * Delete global user task listener
+     *
+     * Deletes a global user task listener.
+     * @see DELETE /global-task-listeners/{id}
+     */
+    deleteGlobalTaskListener(id: string): Promise<void>;
+    /**
+     * Search global user task listeners
+     *
+     * Search for global user task listeners based on given criteria.
+     * @see POST /global-task-listeners/search
+     */
+    searchGlobalTaskListeners(body?: Types.GlobalTaskListenerSearchQueryRequest): Promise<Types.GlobalTaskListenerSearchQueryResult>;
+}
+export declare class GroupResource extends ResourceBase {
+    /**
+     * Create group
+     *
+     * Create a new group.
+     * @see POST /groups
+     */
+    createGroup(body?: Types.GroupCreateRequest): Promise<Types.GroupCreateResult>;
+    /**
+     * Search groups
+     *
+     * Search for groups based on given criteria.
+     * @see POST /groups/search
+     */
+    searchGroups(body?: Types.GroupSearchQueryRequest): Promise<Types.GroupSearchQueryResult>;
+    /**
+     * Get group
+     *
+     * Get a group by its ID.
+     * @see GET /groups/{groupId}
+     */
+    getGroup(groupId: string): Promise<Types.GroupResult>;
+    /**
+     * Update group
+     *
+     * Update a group with the given ID.
+     * @see PUT /groups/{groupId}
+     */
+    updateGroup(groupId: string, body: Types.GroupUpdateRequest): Promise<Types.GroupUpdateResult>;
+    /**
+     * Delete group
+     *
+     * Deletes the group with the given ID.
+     * @see DELETE /groups/{groupId}
+     */
+    deleteGroup(groupId: string): Promise<void>;
+    /**
+     * Search group clients
+     *
+     * Search clients assigned to a group.
+     * @see POST /groups/{groupId}/clients/search
+     */
+    searchClientsForGroup(groupId: string, body?: Types.GroupClientSearchQueryRequest): Promise<Types.GroupClientSearchResult>;
+    /**
+     * Assign a client to a group
+     *
+     *  Assigns a client to a group, making it a member of the group.
+     *  Members of the group inherit the group authorizations, roles, and tenant assignments.
+     * @see PUT /groups/{groupId}/clients/{clientId}
+     */
+    assignClientToGroup(groupId: string, clientId: string): Promise<void>;
+    /**
+     * Unassign a client from a group
+     *
+     *  Unassigns a client from a group.
+     *  The client is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.
+     * @see DELETE /groups/{groupId}/clients/{clientId}
+     */
+    unassignClientFromGroup(groupId: string, clientId: string): Promise<void>;
+    /**
+     * Search group mapping rules
+     *
+     * Search mapping rules assigned to a group.
+     * @see POST /groups/{groupId}/mapping-rules/search
+     */
+    searchMappingRulesForGroup(groupId: string, body?: Types.MappingRuleSearchQueryRequest): Promise<Types.GroupMappingRuleSearchResult>;
+    /**
+     * Assign a mapping rule to a group
+     *
+     * Assigns a mapping rule to a group.
+     * @see PUT /groups/{groupId}/mapping-rules/{mappingRuleId}
+     */
+    assignMappingRuleToGroup(groupId: string, mappingRuleId: string): Promise<void>;
+    /**
+     * Unassign a mapping rule from a group
+     *
+     * Unassigns a mapping rule from a group.
+     * @see DELETE /groups/{groupId}/mapping-rules/{mappingRuleId}
+     */
+    unassignMappingRuleFromGroup(groupId: string, mappingRuleId: string): Promise<void>;
+    /**
+     * Search group roles
+     *
+     * Search roles assigned to a group.
+     * @see POST /groups/{groupId}/roles/search
+     */
+    searchRolesForGroup(groupId: string, body?: Types.RoleSearchQueryRequest): Promise<Types.GroupRoleSearchResult>;
+    /**
+     * Search group users
+     *
+     * Search users assigned to a group.
+     * @see POST /groups/{groupId}/users/search
+     */
+    searchUsersForGroup(groupId: string, body?: Types.GroupUserSearchQueryRequest): Promise<Types.GroupUserSearchResult>;
+    /**
+     * Assign a user to a group
+     *
+     *  Assigns a user to a group, making the user a member of the group.
+     *  Group members inherit the group authorizations, roles, and tenant assignments.
+     * @see PUT /groups/{groupId}/users/{username}
+     */
+    assignUserToGroup(groupId: string, username: string): Promise<void>;
+    /**
+     * Unassign a user from a group
+     *
+     *  Unassigns a user from a group.
+     *  The user is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.
+     * @see DELETE /groups/{groupId}/users/{username}
+     */
+    unassignUserFromGroup(groupId: string, username: string): Promise<void>;
+}
+export declare class IncidentResource extends ResourceBase {
+    /**
+     * Search incidents
+     *
+     *  Search for incidents based on given criteria.
+     * @see POST /incidents/search
+     */
+    searchIncidents(body?: Types.IncidentSearchQuery): Promise<Types.IncidentSearchQueryResult>;
+    /**
+     * Get incident
+     *
+     *  Returns incident as JSON.
+     * @see GET /incidents/{incidentKey}
+     */
+    getIncident(incidentKey: string): Promise<Types.IncidentResult>;
+    /**
+     * Resolve incident
+     *
+     *  Marks the incident as resolved; most likely a call to Update job will be necessary
+     *  to reset the job's retries, followed by this call.
+     * @see POST /incidents/{incidentKey}/resolution
+     */
+    resolveIncident(incidentKey: string, body?: Types.IncidentResolutionRequest): Promise<void>;
+    /**
+     * Get process instance statistics by definition
+     *
+     *  Returns statistics for active process instances with incidents, grouped by process
+     *  definition. The result set is scoped to a specific incident error hash code, which must be
+     *  provided as a filter in the request body.
+     * @see POST /incidents/statistics/process-instances-by-definition
+     */
+    getProcessInstanceStatisticsByDefinition(body: Types.IncidentProcessInstanceStatisticsByDefinitionQuery): Promise<Types.IncidentProcessInstanceStatisticsByDefinitionQueryResult>;
+    /**
+     * Get process instance statistics by error
+     *
+     *  Returns statistics for active process instances that currently have active incidents,
+     *  grouped by incident error hash code.
+     * @see POST /incidents/statistics/process-instances-by-error
+     */
+    getProcessInstanceStatisticsByError(body?: Types.IncidentProcessInstanceStatisticsByErrorQuery): Promise<Types.IncidentProcessInstanceStatisticsByErrorQueryResult>;
+}
+export declare class JobResource extends ResourceBase {
+    /**
+     * Activate jobs
+     *
+     *  Iterate through all known partitions and activate jobs up to the requested maximum.
+     * @see POST /jobs/activation
+     */
+    activateJobs(body: Types.JobActivationRequest): Promise<Types.JobActivationResult>;
+    /**
+     * Search jobs
+     *
+     * Search for jobs based on given criteria.
+     * @see POST /jobs/search
+     */
+    searchJobs(body?: Types.JobSearchQuery): Promise<Types.JobSearchQueryResult>;
+    /**
+     * Update job
+     *
+     * Update a job with the given key.
+     * @see PATCH /jobs/{jobKey}
+     */
+    updateJob(jobKey: string, body: Types.JobUpdateRequest): Promise<void>;
+    /**
+     * Complete job
+     *
+     *  Complete a job with the given payload, which allows completing the associated service task.
+     * @see POST /jobs/{jobKey}/completion
+     */
+    completeJob(jobKey: string, body?: Types.JobCompletionRequest): Promise<void>;
+    /**
+     * Throw error for job
+     *
+     *  Reports a business error (i.e. non-technical) that occurs while processing a job.
+     * @see POST /jobs/{jobKey}/error
+     */
+    throwJobError(jobKey: string, body: Types.JobErrorRequest): Promise<void>;
+    /**
+     * Fail job
+     *
+     *  Mark the job as failed.
+     * @see POST /jobs/{jobKey}/failure
+     */
+    failJob(jobKey: string, body?: Types.JobFailRequest): Promise<void>;
+    /**
+     * Global job statistics
+     *
+     *  Returns global aggregated counts for jobs. Optionally filter by the creation time window and/or jobType.
+     * @see GET /jobs/statistics/global
+     */
+    getGlobalJobStatistics(query?: {
+        from: string;
+        to: string;
+        jobType?: string;
+    }): Promise<Types.GlobalJobStatisticsQueryResult>;
+    /**
+     * Get job statistics by type
+     *
+     *  Get statistics about jobs, grouped by job type.
+     * @see POST /jobs/statistics/by-types
+     */
+    getJobTypeStatistics(body: Types.JobTypeStatisticsQuery): Promise<Types.JobTypeStatisticsQueryResult>;
+    /**
+     * Get job statistics by worker
+     *
+     *  Returns aggregated metrics per worker for the given jobType.
+     * @see POST /jobs/statistics/by-workers
+     */
+    getJobWorkerStatistics(body: Types.JobWorkerStatisticsQuery): Promise<Types.JobWorkerStatisticsQueryResult>;
+    /**
+     * Get time-series metrics for a job type
+     *
+     *  Returns a list of time-bucketed metrics ordered ascending by time.
+     *  The `from` and `to` fields select the time window of interest.
+     *  Each item in the response corresponds to one time bucket of the requested resolution.
+     * @see POST /jobs/statistics/time-series
+     */
+    getJobTimeSeriesStatistics(body: Types.JobTimeSeriesStatisticsQuery): Promise<Types.JobTimeSeriesStatisticsQueryResult>;
+}
+export declare class LicenseResource extends ResourceBase {
+    /**
+     * Get license status
+     *
+     * Obtains the status of the current Camunda license.
+     * @see GET /license
+     */
+    getLicense(): Promise<Types.LicenseResponse>;
+}
+export declare class MappingRuleResource extends ResourceBase {
+    /**
+     * Create mapping rule
+     *
+     *  Create a new mapping rule
+     * @see POST /mapping-rules
+     */
+    createMappingRule(body?: Types.MappingRuleCreateRequest): Promise<Types.MappingRuleCreateResult>;
+    /**
+     * Search mapping rules
+     *
+     *  Search for mapping rules based on given criteria.
+     * @see POST /mapping-rules/search
+     */
+    searchMappingRule(body?: Types.MappingRuleSearchQueryRequest): Promise<Types.MappingRuleSearchQueryResult>;
+    /**
+     * Get a mapping rule
+     *
+     *  Gets the mapping rule with the given ID.
+     * @see GET /mapping-rules/{mappingRuleId}
+     */
+    getMappingRule(mappingRuleId: string): Promise<Types.MappingRuleResult>;
+    /**
+     * Update mapping rule
+     *
+     *  Update a mapping rule.
+     * @see PUT /mapping-rules/{mappingRuleId}
+     */
+    updateMappingRule(mappingRuleId: string, body?: Types.MappingRuleUpdateRequest): Promise<Types.MappingRuleUpdateResult>;
+    /**
+     * Delete a mapping rule
+     *
+     *  Deletes the mapping rule with the given ID.
+     * @see DELETE /mapping-rules/{mappingRuleId}
+     */
+    deleteMappingRule(mappingRuleId: string): Promise<void>;
+}
+export declare class MessageResource extends ResourceBase {
+    /**
+     * Correlate message
+     *
+     *  Publishes a message and correlates it to a subscription.
+     *  If correlation is successful it will return the first process instance key the message correlated with.
+     *  The message is not buffered.
+     * @see POST /messages/correlation
+     */
+    correlateMessage(body: Types.MessageCorrelationRequest): Promise<Types.MessageCorrelationResult>;
+    /**
+     * Publish message
+     *
+     *  Publishes a single message.
+     *  Messages are published to specific partitions computed from their correlation keys.
+     *  Messages can be buffered.
+     * @see POST /messages/publication
+     */
+    publishMessage(body: Types.MessagePublicationRequest): Promise<Types.MessagePublicationResult>;
+}
+export declare class ProcessDefinitionResource extends ResourceBase {
+    /**
+     * Search process definitions
+     *
+     * Search for process definitions based on given criteria.
+     * @see POST /process-definitions/search
+     */
+    searchProcessDefinitions(body?: Types.ProcessDefinitionSearchQuery): Promise<Types.ProcessDefinitionSearchQueryResult>;
+    /**
+     * Get message subscription statistics
+     *
+     *  Get message subscription statistics, grouped by process definition.
+     * @see POST /process-definitions/statistics/message-subscriptions
+     */
+    getProcessDefinitionMessageSubscriptionStatistics(body?: Types.ProcessDefinitionMessageSubscriptionStatisticsQuery): Promise<Types.ProcessDefinitionMessageSubscriptionStatisticsQueryResult>;
+    /**
+     * Get process instance statistics
+     *
+     *  Get statistics about process instances, grouped by process definition and tenant.
+     * @see POST /process-definitions/statistics/process-instances
+     */
+    getProcessDefinitionInstanceStatistics(body?: Types.ProcessDefinitionInstanceStatisticsQuery): Promise<Types.ProcessDefinitionInstanceStatisticsQueryResult>;
+    /**
+     * Get process definition
+     *
+     * Returns process definition as JSON.
+     * @see GET /process-definitions/{processDefinitionKey}
+     */
+    getProcessDefinition(processDefinitionKey: string): Promise<Types.ProcessDefinitionResult>;
+    /**
+     * Get process start form
+     *
+     *  Get the start form of a process.
+     *  Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.
+     * @see GET /process-definitions/{processDefinitionKey}/form
+     */
+    getStartProcessForm(processDefinitionKey: string): Promise<Types.FormResult>;
+    /**
+     * Get process definition statistics
+     *
+     * Get statistics about elements in currently running process instances by process definition key and search filter.
+     * @see POST /process-definitions/{processDefinitionKey}/statistics/element-instances
+     */
+    getProcessDefinitionStatistics(processDefinitionKey: string, body?: Types.ProcessDefinitionElementStatisticsQuery): Promise<Types.ProcessDefinitionElementStatisticsQueryResult>;
+    /**
+     * Get process definition XML
+     *
+     * Returns process definition as XML.
+     * @see GET /process-definitions/{processDefinitionKey}/xml
+     */
+    getProcessDefinitionXML(processDefinitionKey: string): Promise<void>;
+    /**
+     * Get process instance statistics by version
+     *
+     *  Get statistics about process instances, grouped by version for a given process definition.
+     *  The process definition ID must be provided as a required field in the request body filter.
+     * @see POST /process-definitions/statistics/process-instances-by-version
+     */
+    getProcessDefinitionInstanceVersionStatistics(body: Types.ProcessDefinitionInstanceVersionStatisticsQuery): Promise<Types.ProcessDefinitionInstanceVersionStatisticsQueryResult>;
+}
+export declare class ProcessInstanceResource extends ResourceBase {
+    /**
+     * Create process instance
+     *
+     *  Creates and starts an instance of the specified process.
+     *  The process definition to use to create the instance can be specified either using its unique key
+     *  (as returned by Deploy resources), or using the BPMN process id and a version.
+     * @see POST /process-instances
+     */
+    createProcessInstance(body: Types.ProcessInstanceCreationInstruction): Promise<Types.CreateProcessInstanceResult>;
+    /**
+     * Cancel process instances (batch)
+     *
+     *  Cancels multiple running process instances.
+     *  Since only ACTIVE root instances can be cancelled, any given filters for state and
+     *  parentProcessInstanceKey are ignored and overridden during this batch operation.
+     * @see POST /process-instances/cancellation
+     */
+    cancelProcessInstancesBatchOperation(body: Types.ProcessInstanceCancellationBatchOperationRequest): Promise<Types.BatchOperationCreatedResult>;
+    /**
+     * Delete process instances (batch)
+     *
+     *  Delete multiple process instances. This will delete the historic data from secondary storage.
+     *  Only process instances in a final state (COMPLETED or TERMINATED) can be deleted.
+     *  This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).
+     * @see POST /process-instances/deletion
+     */
+    deleteProcessInstancesBatchOperation(body: Types.ProcessInstanceDeletionBatchOperationRequest): Promise<Types.BatchOperationCreatedResult>;
+    /**
+     * Resolve related incidents (batch)
+     *
+     *  Resolves multiple instances of process instances.
+     *  Since only process instances with ACTIVE state can have unresolved incidents, any given
+     *  filters for state are ignored and overridden during this batch operation.
+     * @see POST /process-instances/incident-resolution
+     */
+    resolveIncidentsBatchOperation(body?: Types.ProcessInstanceIncidentResolutionBatchOperationRequest): Promise<Types.BatchOperationCreatedResult>;
+    /**
+     * Migrate process instances (batch)
+     *
+     *  Migrate multiple process instances.
+     *  Since only process instances with ACTIVE state can be migrated, any given
+     *  filters for state are ignored and overridden during this batch operation.
+     * @see POST /process-instances/migration
+     */
+    migrateProcessInstancesBatchOperation(body: Types.ProcessInstanceMigrationBatchOperationRequest): Promise<Types.BatchOperationCreatedResult>;
+    /**
+     * Modify process instances (batch)
+     *
+     *  Modify multiple process instances.
+     *  Since only process instances with ACTIVE state can be modified, any given
+     *  filters for state are ignored and overridden during this batch operation.
+     * @see POST /process-instances/modification
+     */
+    modifyProcessInstancesBatchOperation(body: Types.ProcessInstanceModificationBatchOperationRequest): Promise<Types.BatchOperationCreatedResult>;
+    /**
+     * Search process instances
+     *
+     * Search for process instances based on given criteria.
+     * @see POST /process-instances/search
+     */
+    searchProcessInstances(body?: Types.ProcessInstanceSearchQuery): Promise<Types.ProcessInstanceSearchQueryResult>;
+    /**
+     * Get process instance
+     *
+     * Get the process instance by the process instance key.
+     * @see GET /process-instances/{processInstanceKey}
+     */
+    getProcessInstance(processInstanceKey: string): Promise<Types.ProcessInstanceResult>;
+    /**
+     * Get call hierarchy
+     *
+     * Returns the call hierarchy for a given process instance, showing its ancestry up to the root instance.
+     * @see GET /process-instances/{processInstanceKey}/call-hierarchy
+     */
+    getProcessInstanceCallHierarchy(processInstanceKey: string): Promise<Array<Types.ProcessInstanceCallHierarchyEntry>>;
+    /**
+     * Cancel process instance
+     *
+     * Cancels a running process instance. As a cancellation includes more than just the removal of the process instance resource, the cancellation resource must be posted.
+     * @see POST /process-instances/{processInstanceKey}/cancellation
+     */
+    cancelProcessInstance(processInstanceKey: string, body?: Types.CancelProcessInstanceRequest): Promise<void>;
+    /**
+     * Delete process instance
+     *
+     * Deletes a process instance. Only instances that are completed or terminated can be deleted.
+     * @see POST /process-instances/{processInstanceKey}/deletion
+     */
+    deleteProcessInstance(processInstanceKey: string, body?: Types.DeleteProcessInstanceRequest): Promise<void>;
+    /**
+     * Resolve related incidents
+     *
+     * Creates a batch operation to resolve multiple incidents of a process instance.
+     * @see POST /process-instances/{processInstanceKey}/incident-resolution
+     */
+    resolveProcessInstanceIncidents(processInstanceKey: string): Promise<Types.BatchOperationCreatedResult>;
+    /**
+     * Search related incidents
+     *
+     *  Search for incidents caused by the process instance or any of its called process or decision instances.
+     *
+     *  Although the `processInstanceKey` is provided as a path parameter to indicate the root process instance,
+     * @see POST /process-instances/{processInstanceKey}/incidents/search
+     */
+    searchProcessInstanceIncidents(processInstanceKey: string, body?: Types.IncidentSearchQuery): Promise<Types.IncidentSearchQueryResult>;
+    /**
+     * Migrate process instance
+     *
+     *  Migrates a process instance to a new process definition.
+     *  This request can contain multiple mapping instructions to define mapping between the active
+     *  process instance's elements and target process definition elements.
+     * @see POST /process-instances/{processInstanceKey}/migration
+     */
+    migrateProcessInstance(processInstanceKey: string, body: Types.ProcessInstanceMigrationInstruction): Promise<void>;
+    /**
+     * Modify process instance
+     *
+     *  Modifies a running process instance.
+     *  This request can contain multiple instructions to activate an element of the process or
+     *  to terminate an active instance of an element.
+     * @see POST /process-instances/{processInstanceKey}/modification
+     */
+    modifyProcessInstance(processInstanceKey: string, body: Types.ProcessInstanceModificationInstruction): Promise<void>;
+    /**
+     * Get sequence flows
+     *
+     * Get sequence flows taken by the process instance.
+     * @see GET /process-instances/{processInstanceKey}/sequence-flows
+     */
+    getProcessInstanceSequenceFlows(processInstanceKey: string): Promise<Types.ProcessInstanceSequenceFlowsQueryResult>;
+    /**
+     * Get element instance statistics
+     *
+     * Get statistics about elements by the process instance key.
+     * @see GET /process-instances/{processInstanceKey}/statistics/element-instances
+     */
+    getProcessInstanceStatistics(processInstanceKey: string): Promise<Types.ProcessInstanceElementStatisticsQueryResult>;
+}
+export declare class RoleResource extends ResourceBase {
+    /**
+     * Create role
+     *
+     * Create a new role.
+     * @see POST /roles
+     */
+    createRole(body?: Types.RoleCreateRequest): Promise<Types.RoleCreateResult>;
+    /**
+     * Search roles
+     *
+     * Search for roles based on given criteria.
+     * @see POST /roles/search
+     */
+    searchRoles(body?: Types.RoleSearchQueryRequest): Promise<Types.RoleSearchQueryResult>;
+    /**
+     * Get role
+     *
+     * Get a role by its ID.
+     * @see GET /roles/{roleId}
+     */
+    getRole(roleId: string): Promise<Types.RoleResult>;
+    /**
+     * Update role
+     *
+     * Update a role with the given ID.
+     * @see PUT /roles/{roleId}
+     */
+    updateRole(roleId: string, body: Types.RoleUpdateRequest): Promise<Types.RoleUpdateResult>;
+    /**
+     * Delete role
+     *
+     * Deletes the role with the given ID.
+     * @see DELETE /roles/{roleId}
+     */
+    deleteRole(roleId: string): Promise<void>;
+    /**
+     * Search role clients
+     *
+     * Search clients with assigned role.
+     * @see POST /roles/{roleId}/clients/search
+     */
+    searchClientsForRole(roleId: string, body?: Types.RoleClientSearchQueryRequest): Promise<Types.RoleClientSearchResult>;
+    /**
+     * Assign a role to a client
+     *
+     * Assigns the specified role to the client. The client will inherit the authorizations associated with this role.
+     * @see PUT /roles/{roleId}/clients/{clientId}
+     */
+    assignRoleToClient(roleId: string, clientId: string): Promise<void>;
+    /**
+     * Unassign a role from a client
+     *
+     * Unassigns the specified role from the client. The client will no longer inherit the authorizations associated with this role.
+     * @see DELETE /roles/{roleId}/clients/{clientId}
+     */
+    unassignRoleFromClient(roleId: string, clientId: string): Promise<void>;
+    /**
+     * Search role groups
+     *
+     * Search groups with assigned role.
+     * @see POST /roles/{roleId}/groups/search
+     */
+    searchGroupsForRole(roleId: string, body?: Types.RoleGroupSearchQueryRequest): Promise<Types.RoleGroupSearchResult>;
+    /**
+     * Assign a role to a group
+     *
+     * Assigns the specified role to the group. Every member of the group (user or client) will inherit the authorizations associated with this role.
+     * @see PUT /roles/{roleId}/groups/{groupId}
+     */
+    assignRoleToGroup(roleId: string, groupId: string): Promise<void>;
+    /**
+     * Unassign a role from a group
+     *
+     * Unassigns the specified role from the group. All group members (user or client) no longer inherit the authorizations associated with this role.
+     * @see DELETE /roles/{roleId}/groups/{groupId}
+     */
+    unassignRoleFromGroup(roleId: string, groupId: string): Promise<void>;
+    /**
+     * Search role mapping rules
+     *
+     * Search mapping rules with assigned role.
+     * @see POST /roles/{roleId}/mapping-rules/search
+     */
+    searchMappingRulesForRole(roleId: string, body?: Types.MappingRuleSearchQueryRequest): Promise<Types.RoleMappingRuleSearchResult>;
+    /**
+     * Assign a role to a mapping rule
+     *
+     * Assigns a role to a mapping rule.
+     * @see PUT /roles/{roleId}/mapping-rules/{mappingRuleId}
+     */
+    assignRoleToMappingRule(roleId: string, mappingRuleId: string): Promise<void>;
+    /**
+     * Unassign a role from a mapping rule
+     *
+     * Unassigns a role from a mapping rule.
+     * @see DELETE /roles/{roleId}/mapping-rules/{mappingRuleId}
+     */
+    unassignRoleFromMappingRule(roleId: string, mappingRuleId: string): Promise<void>;
+    /**
+     * Search role users
+     *
+     * Search users with assigned role.
+     * @see POST /roles/{roleId}/users/search
+     */
+    searchUsersForRole(roleId: string, body?: Types.RoleUserSearchQueryRequest): Promise<Types.RoleUserSearchResult>;
+    /**
+     * Assign a role to a user
+     *
+     * Assigns the specified role to the user. The user will inherit the authorizations associated with this role.
+     * @see PUT /roles/{roleId}/users/{username}
+     */
+    assignRoleToUser(roleId: string, username: string): Promise<void>;
+    /**
+     * Unassign a role from a user
+     *
+     * Unassigns a role from a user. The user will no longer inherit the authorizations associated with this role.
+     * @see DELETE /roles/{roleId}/users/{username}
+     */
+    unassignRoleFromUser(roleId: string, username: string): Promise<void>;
+}
+export declare class SetupResource extends ResourceBase {
+    /**
+     * Create admin user
+     *
+     * Creates a new user and assigns the admin role to it. This endpoint is only usable when users are managed in the Orchestration Cluster and while no user is assigned to the admin role.
+     * @see POST /setup/user
+     */
+    createAdminUser(body: Types.UserRequest): Promise<Types.UserCreateResult>;
+}
+export declare class SignalResource extends ResourceBase {
+    /**
+     * Broadcast signal
+     *
+     * Broadcasts a signal.
+     * @see POST /signals/broadcast
+     */
+    broadcastSignal(body: Types.SignalBroadcastRequest): Promise<Types.SignalBroadcastResult>;
+}
+export declare class ClusterResource extends ResourceBase {
+    /**
+     * Get cluster status
+     *
+     * Checks the health status of the cluster by verifying if there's at least one partition with a healthy leader.
+     * @see GET /status
+     */
+    getStatus(): Promise<void>;
+    /**
+     * Get cluster topology
+     *
+     * Obtains the current topology of the cluster the gateway is part of.
+     * @see GET /topology
+     */
+    getTopology(): Promise<Types.TopologyResponse>;
+}
+export declare class SystemResource extends ResourceBase {
+    /**
+     * Get usage metrics
+     *
+     * Retrieve the usage metrics based on given criteria.
+     * @see GET /system/usage-metrics
+     */
+    getUsageMetrics(query?: {
+        startTime: string;
+        endTime: string;
+        tenantId?: Types.TenantId;
+        withTenants?: boolean;
+    }): Promise<Types.UsageMetricsResponse>;
+}
+export declare class TenantResource extends ResourceBase {
+    /**
+     * Create tenant
+     *
+     * Creates a new tenant.
+     * @see POST /tenants
+     */
+    createTenant(body: Types.TenantCreateRequest): Promise<Types.TenantCreateResult>;
+    /**
+     * Search tenants
+     *
+     * Retrieves a filtered and sorted list of tenants.
+     * @see POST /tenants/search
+     */
+    searchTenants(body?: Types.TenantSearchQueryRequest): Promise<Types.TenantSearchQueryResult>;
+    /**
+     * Get tenant
+     *
+     * Retrieves a single tenant by tenant ID.
+     * @see GET /tenants/{tenantId}
+     */
+    getTenant(tenantId: string): Promise<Types.TenantResult>;
+    /**
+     * Update tenant
+     *
+     * Updates an existing tenant.
+     * @see PUT /tenants/{tenantId}
+     */
+    updateTenant(tenantId: string, body: Types.TenantUpdateRequest): Promise<Types.TenantUpdateResult>;
+    /**
+     * Delete tenant
+     *
+     * Deletes an existing tenant.
+     * @see DELETE /tenants/{tenantId}
+     */
+    deleteTenant(tenantId: string): Promise<void>;
+    /**
+     * Search clients for tenant
+     *
+     * Retrieves a filtered and sorted list of clients for a specified tenant.
+     * @see POST /tenants/{tenantId}/clients/search
+     */
+    searchClientsForTenant(tenantId: string, body?: Types.TenantClientSearchQueryRequest): Promise<Types.TenantClientSearchResult>;
+    /**
+     * Assign a client to a tenant
+     *
+     *  Assign the client to the specified tenant.
+     *  The client can then access tenant data and perform authorized actions.
+     * @see PUT /tenants/{tenantId}/clients/{clientId}
+     */
+    assignClientToTenant(tenantId: string, clientId: string): Promise<void>;
+    /**
+     * Unassign a client from a tenant
+     *
+     *  Unassigns the client from the specified tenant.
+     *  The client can no longer access tenant data.
+     * @see DELETE /tenants/{tenantId}/clients/{clientId}
+     */
+    unassignClientFromTenant(tenantId: string, clientId: string): Promise<void>;
+    /**
+     * Search groups for tenant
+     *
+     * Retrieves a filtered and sorted list of groups for a specified tenant.
+     * @see POST /tenants/{tenantId}/groups/search
+     */
+    searchGroupIdsForTenant(tenantId: string, body?: Types.TenantGroupSearchQueryRequest): Promise<Types.TenantGroupSearchResult>;
+    /**
+     * Assign a group to a tenant
+     *
+     *  Assigns a group to a specified tenant.
+     *  Group members (users, clients) can then access tenant data and perform authorized actions.
+     * @see PUT /tenants/{tenantId}/groups/{groupId}
+     */
+    assignGroupToTenant(tenantId: string, groupId: string): Promise<void>;
+    /**
+     * Unassign a group from a tenant
+     *
+     *  Unassigns a group from a specified tenant.
+     *  Members of the group (users, clients) will no longer have access to the tenant's data - except they are assigned directly to the tenant.
+     * @see DELETE /tenants/{tenantId}/groups/{groupId}
+     */
+    unassignGroupFromTenant(tenantId: string, groupId: string): Promise<void>;
+    /**
+     * Search mapping rules for tenant
+     *
+     * Retrieves a filtered and sorted list of MappingRules for a specified tenant.
+     * @see POST /tenants/{tenantId}/mapping-rules/search
+     */
+    searchMappingRulesForTenant(tenantId: string, body?: Types.MappingRuleSearchQueryRequest): Promise<Types.TenantMappingRuleSearchResult>;
+    /**
+     * Assign a mapping rule to a tenant
+     *
+     * Assign a single mapping rule to a specified tenant.
+     * @see PUT /tenants/{tenantId}/mapping-rules/{mappingRuleId}
+     */
+    assignMappingRuleToTenant(tenantId: string, mappingRuleId: string): Promise<void>;
+    /**
+     * Unassign a mapping rule from a tenant
+     *
+     * Unassigns a single mapping rule from a specified tenant without deleting the rule.
+     * @see DELETE /tenants/{tenantId}/mapping-rules/{mappingRuleId}
+     */
+    unassignMappingRuleFromTenant(tenantId: string, mappingRuleId: string): Promise<void>;
+    /**
+     * Search roles for tenant
+     *
+     * Retrieves a filtered and sorted list of roles for a specified tenant.
+     * @see POST /tenants/{tenantId}/roles/search
+     */
+    searchRolesForTenant(tenantId: string, body?: Types.RoleSearchQueryRequest): Promise<Types.TenantRoleSearchResult>;
+    /**
+     * Assign a role to a tenant
+     *
+     *  Assigns a role to a specified tenant.
+     *  Users, Clients or Groups, that have the role assigned, will get access to the tenant's data and can perform actions according to their authorizations.
+     * @see PUT /tenants/{tenantId}/roles/{roleId}
+     */
+    assignRoleToTenant(tenantId: string, roleId: string): Promise<void>;
+    /**
+     * Unassign a role from a tenant
+     *
+     *  Unassigns a role from a specified tenant.
+     *  Users, Clients or Groups, that have the role assigned, will no longer have access to the
+     *  tenant's data - unless they are assigned directly to the tenant.
+     * @see DELETE /tenants/{tenantId}/roles/{roleId}
+     */
+    unassignRoleFromTenant(tenantId: string, roleId: string): Promise<void>;
+    /**
+     * Search users for tenant
+     *
+     * Retrieves a filtered and sorted list of users for a specified tenant.
+     * @see POST /tenants/{tenantId}/users/search
+     */
+    searchUsersForTenant(tenantId: string, body?: Types.TenantUserSearchQueryRequest): Promise<Types.TenantUserSearchResult>;
+    /**
+     * Assign a user to a tenant
+     *
+     * Assign a single user to a specified tenant. The user can then access tenant data and perform authorized actions.
+     * @see PUT /tenants/{tenantId}/users/{username}
+     */
+    assignUserToTenant(tenantId: string, username: string): Promise<void>;
+    /**
+     * Unassign a user from a tenant
+     *
+     *  Unassigns the user from the specified tenant.
+     *  The user can no longer access tenant data.
+     * @see DELETE /tenants/{tenantId}/users/{username}
+     */
+    unassignUserFromTenant(tenantId: string, username: string): Promise<void>;
+}
+export declare class UserResource extends ResourceBase {
+    /**
+     * Create user
+     *
+     * Create a new user.
+     * @see POST /users
+     */
+    createUser(body: Types.UserRequest): Promise<Types.UserCreateResult>;
+    /**
+     * Search users
+     *
+     * Search for users based on given criteria.
+     * @see POST /users/search
+     */
+    searchUsers(body?: Types.UserSearchQueryRequest): Promise<Types.UserSearchResult>;
+    /**
+     * Get user
+     *
+     * Get a user by its username.
+     * @see GET /users/{username}
+     */
+    getUser(username: string): Promise<Types.UserResult>;
+    /**
+     * Update user
+     *
+     * Updates a user.
+     * @see PUT /users/{username}
+     */
+    updateUser(username: string, body: Types.UserUpdateRequest): Promise<Types.UserUpdateResult>;
+    /**
+     * Delete user
+     *
+     * Deletes a user.
+     * @see DELETE /users/{username}
+     */
+    deleteUser(username: string): Promise<void>;
+}
+export declare class UserTaskResource extends ResourceBase {
+    /**
+     * Search user tasks
+     *
+     * Search for user tasks based on given criteria.
+     * @see POST /user-tasks/search
+     */
+    searchUserTasks(body?: Types.UserTaskSearchQuery): Promise<Types.UserTaskSearchQueryResult>;
+    /**
+     * Get user task
+     *
+     * Get the user task by the user task key.
+     * @see GET /user-tasks/{userTaskKey}
+     */
+    getUserTask(userTaskKey: string): Promise<Types.UserTaskResult>;
+    /**
+     * Update user task
+     *
+     * Update a user task with the given key.
+     * @see PATCH /user-tasks/{userTaskKey}
+     */
+    updateUserTask(userTaskKey: string, body?: Types.UserTaskUpdateRequest): Promise<void>;
+    /**
+     * Unassign user task
+     *
+     * Removes the assignee of a task with the given key.
+     * @see DELETE /user-tasks/{userTaskKey}/assignee
+     */
+    unassignUserTask(userTaskKey: string): Promise<void>;
+    /**
+     * Assign user task
+     *
+     * Assigns a user task with the given key to the given assignee.
+     * @see POST /user-tasks/{userTaskKey}/assignment
+     */
+    assignUserTask(userTaskKey: string, body: Types.UserTaskAssignmentRequest): Promise<void>;
+    /**
+     * Search user task audit logs
+     *
+     * Search for user task audit logs based on given criteria.
+     * @see POST /user-tasks/{userTaskKey}/audit-logs/search
+     */
+    searchUserTaskAuditLogs(userTaskKey: string, body?: Types.UserTaskAuditLogSearchQueryRequest): Promise<Types.AuditLogSearchQueryResult>;
+    /**
+     * Complete user task
+     *
+     * Completes a user task with the given key.
+     * @see POST /user-tasks/{userTaskKey}/completion
+     */
+    completeUserTask(userTaskKey: string, body?: Types.UserTaskCompletionRequest): Promise<void>;
+    /**
+     * Get user task form
+     *
+     *  Get the form of a user task.
+     *  Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.
+     * @see GET /user-tasks/{userTaskKey}/form
+     */
+    getUserTaskForm(userTaskKey: string): Promise<Types.FormResult>;
+    /**
+     * Search user task variables
+     *
+     *  Search for user task variables based on given criteria. This endpoint returns all variables
+     *  visible from the user task's scope, including variables from parent scopes in the scope
+     *  hierarchy. By default, long variable values in the response are truncated.
+     * @see POST /user-tasks/{userTaskKey}/variables/search
+     */
+    searchUserTaskVariables(userTaskKey: string, body?: Types.UserTaskVariableSearchQueryRequest, query?: {
+        truncateValues?: boolean;
+    }): Promise<Types.VariableSearchQueryResult>;
+}
+export declare class VariableResource extends ResourceBase {
+    /**
+     * Search variables
+     *
+     *  Search for variables based on given criteria.
+     *
+     *  This endpoint returns variables that exist directly at the specified scopes - it does not
+     * @see POST /variables/search
+     */
+    searchVariables(body?: Types.VariableSearchQuery, query?: {
+        truncateValues?: boolean;
+    }): Promise<Types.VariableSearchQueryResult>;
+    /**
+     * Get variable
+     *
+     *  Get a variable by its key.
+     *
+     *  This endpoint returns both process-level and local (element-scoped) variables.
+     * @see GET /variables/{variableKey}
+     */
+    getVariable(variableKey: string): Promise<Types.VariableResult>;
+}
+/**
+ * Camunda Orchestration Cluster API client.
+ */
+export declare class CamundaClient extends CamundaBaseClient {
+    /** Audit Log operations */
+    readonly auditLog: AuditLogResource;
+    /** Authentication operations */
+    readonly authentication: AuthenticationResource;
+    /** Authorization operations */
+    readonly authorization: AuthorizationResource;
+    /** Batch operation operations */
+    readonly batchOperation: BatchOperationResource;
+    /** Clock operations */
+    readonly clock: ClockResource;
+    /** Cluster Variable operations */
+    readonly clusterVariable: ClusterVariableResource;
+    /** Conditional operations */
+    readonly conditional: ConditionalResource;
+    /** Message subscription operations */
+    readonly messageSubscription: MessageSubscriptionResource;
+    /** Decision definition operations */
+    readonly decisionDefinition: DecisionDefinitionResource;
+    /** Decision instance operations */
+    readonly decisionInstance: DecisionInstanceResource;
+    /** Decision requirements operations */
+    readonly decisionRequirements: DecisionRequirementsResource;
+    /** Resource operations */
+    readonly resource: ResourceResource;
+    /** Document operations */
+    readonly document: DocumentResource;
+    /** Ad-hoc sub-process operations */
+    readonly adHocSubProcess: AdHocSubProcessResource;
+    /** Element instance operations */
+    readonly elementInstance: ElementInstanceResource;
+    /** Expression operations */
+    readonly expression: ExpressionResource;
+    /** Global listener operations */
+    readonly globalListener: GlobalListenerResource;
+    /** Group operations */
+    readonly group: GroupResource;
+    /** Incident operations */
+    readonly incident: IncidentResource;
+    /** Job operations */
+    readonly job: JobResource;
+    /** License operations */
+    readonly license: LicenseResource;
+    /** Mapping rule operations */
+    readonly mappingRule: MappingRuleResource;
+    /** Message operations */
+    readonly message: MessageResource;
+    /** Process definition operations */
+    readonly processDefinition: ProcessDefinitionResource;
+    /** Process instance operations */
+    readonly processInstance: ProcessInstanceResource;
+    /** Role operations */
+    readonly role: RoleResource;
+    /** Setup operations */
+    readonly setup: SetupResource;
+    /** Signal operations */
+    readonly signal: SignalResource;
+    /** Cluster operations */
+    readonly cluster: ClusterResource;
+    /** System operations */
+    readonly system: SystemResource;
+    /** Tenant operations */
+    readonly tenant: TenantResource;
+    /** User operations */
+    readonly user: UserResource;
+    /** User task operations */
+    readonly userTask: UserTaskResource;
+    /** Variable operations */
+    readonly variable: VariableResource;
+    constructor(config?: CamundaClientInput);
+}
+//# sourceMappingURL=resources.d.ts.map