Skip to main content
Version: 8.9 (unreleased)

CamundaClient

Technical Preview

The C# SDK is a technical preview available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.

Creating a Client

Factory method for creating CamundaClient instances.

public static CamundaClient CreateClient(CamundaOptions? options = null)

Create a new CamundaClient.

ParameterTypeDescription
optionsCamundaOptions

Dependency Injection

Extension methods for registering in an .

AddCamundaClient(IServiceCollection)

public static IServiceCollection AddCamundaClient(this IServiceCollection services)

Registers a singleton using zero-config (environment variables only).

ParameterTypeDescription
servicesIServiceCollection

AddCamundaClient(IServiceCollection, IConfiguration)

public static IServiceCollection AddCamundaClient(this IServiceCollection services, IConfiguration configurationSection)

Registers a singleton using an section.

Typically called as services.AddCamundaClient(configuration.GetSection("Camunda")). PascalCase keys in the section are mapped to canonical CAMUNDA_* env-var names internally. Environment variables still apply as a base layer; section values override them.

ParameterTypeDescription
servicesIServiceCollection
configurationSectionIConfiguration

AddCamundaClient(IServiceCollection, Action)

public static IServiceCollection AddCamundaClient(this IServiceCollection services, Action<CamundaOptions> configure)

Registers a singleton with an options callback for full control.

ParameterTypeDescription
servicesIServiceCollection
configureAction<CamundaOptions>

Overview

Primary Camunda client. Provides typed methods for all Camunda 8 REST API operations.

Auto-generated operation methods are added in the Generated/ partial class files. This class provides the infrastructure: configuration, auth, retry, backpressure.

public class CamundaClient : IDisposable, IAsyncDisposable

Constructor

public CamundaClient(CamundaOptions? options = null)

Create a new CamundaClient with the given options.

ParameterTypeDescription
optionsCamundaOptions

Properties

PropertyTypeDescription
ConfigCamundaConfigThe current hydrated configuration (read-only).

Methods

Cluster

GetBackpressureState()

public BackpressureState GetBackpressureState()

Current backpressure state snapshot.

Returns: BackpressureState

GetAuthenticationAsync(CancellationToken)

public Task<CamundaUserResult> GetAuthenticationAsync(CancellationToken ct = default)

Get current user Retrieves the current authenticated user.

ParameterTypeDescription
ctCancellationToken

Returns: Task<CamundaUserResult>

Example

static async Task GetAuthenticationExample()
{
using var client = Camunda.CreateClient();

var user = await client.GetAuthenticationAsync();
Console.WriteLine($"Authenticated as: {user.Username}");
}

GetLicenseAsync(CancellationToken)

public Task<LicenseResponse> GetLicenseAsync(CancellationToken ct = default)

Get license status Obtains the status of the current Camunda license.

ParameterTypeDescription
ctCancellationToken

Returns: Task<LicenseResponse>

GetTopologyAsync(CancellationToken)

public Task<TopologyResponse> GetTopologyAsync(CancellationToken ct = default)

Get cluster topology Obtains the current topology of the cluster the gateway is part of.

ParameterTypeDescription
ctCancellationToken

Returns: Task<TopologyResponse>

Example

static async Task GetTopologyExample()
{
using var client = Camunda.CreateClient();

var topology = await client.GetTopologyAsync();

Console.WriteLine($"Cluster size: {topology.ClusterSize}");
Console.WriteLine($"Partitions: {topology.PartitionsCount}");
foreach (var broker in topology.Brokers)
{
Console.WriteLine($" Broker {broker.NodeId}: {broker.Host}:{broker.Port}");
}
}

PinClockAsync(ClockPinRequest, CancellationToken)

public Task PinClockAsync(ClockPinRequest body, CancellationToken ct = default)

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.

This endpoint is an alpha feature and may be subject to change in future releases.

ParameterTypeDescription
bodyClockPinRequest
ctCancellationToken

Returns: Task

ResetClockAsync(CancellationToken)

public Task ResetClockAsync(CancellationToken ct = default)

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.

This endpoint is an alpha feature and may be subject to change in future releases.

ParameterTypeDescription
ctCancellationToken

Returns: Task

Other

Dispose()

public void Dispose()

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

DisposeAsync()

public ValueTask DisposeAsync()

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources asynchronously.

Returns: ValueTask — A task that represents the asynchronous dispose operation.

CreateAdminUserAsync(UserRequest, ConsistencyOptions?, CancellationToken)
public Task<object> CreateAdminUserAsync(UserRequest body, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

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.

ParameterTypeDescription
bodyUserRequest
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task<Object>

CreateUserAsync(UserRequest, ConsistencyOptions?, CancellationToken)

public Task<UserCreateResult> CreateUserAsync(UserRequest body, ConsistencyOptions<UserCreateResult>? consistency = null, CancellationToken ct = default)

Create user Create a new user.

ParameterTypeDescription
bodyUserRequest
consistencyConsistencyOptions<UserCreateResult>
ctCancellationToken

Returns: Task<UserCreateResult>

DeleteUserAsync(Username, ConsistencyOptions?, CancellationToken)
public Task DeleteUserAsync(Username username, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Delete user Deletes a user.

ParameterTypeDescription
usernameUsername
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task

EvaluateConditionalsAsync(ConditionalEvaluationInstruction, CancellationToken)

public Task<EvaluateConditionalResult> EvaluateConditionalsAsync(ConditionalEvaluationInstruction body, CancellationToken ct = default)

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.

ParameterTypeDescription
bodyConditionalEvaluationInstruction
ctCancellationToken

Returns: Task<EvaluateConditionalResult>

EvaluateExpressionAsync(ExpressionEvaluationRequest, CancellationToken)

public Task<ExpressionEvaluationResult> EvaluateExpressionAsync(ExpressionEvaluationRequest body, CancellationToken ct = default)

Evaluate an expression Evaluates a FEEL expression and returns the result. Supports references to tenant scoped cluster variables when a tenant ID is provided.

ParameterTypeDescription
bodyExpressionEvaluationRequest
ctCancellationToken

Returns: Task<ExpressionEvaluationResult>

GetStatusAsync(CancellationToken)

public Task GetStatusAsync(CancellationToken ct = default)

Get cluster status Checks the health status of the cluster by verifying if there's at least one partition with a healthy leader.

ParameterTypeDescription
ctCancellationToken

Returns: Task

GetUserAsync(Username, ConsistencyOptions?, CancellationToken)

public Task<UserResult> GetUserAsync(Username username, ConsistencyOptions<UserResult>? consistency = null, CancellationToken ct = default)

Get user Get a user by its username.

ParameterTypeDescription
usernameUsername
consistencyConsistencyOptions<UserResult>
ctCancellationToken

Returns: Task<UserResult>

SearchUsersAsync(SearchUsersRequest, ConsistencyOptions?, CancellationToken)

public Task<UserSearchResult> SearchUsersAsync(SearchUsersRequest body, ConsistencyOptions<UserSearchResult>? consistency = null, CancellationToken ct = default)

Search users Search for users based on given criteria.

ParameterTypeDescription
bodySearchUsersRequest
consistencyConsistencyOptions<UserSearchResult>
ctCancellationToken

Returns: Task<UserSearchResult>

UpdateUserAsync(Username, UserUpdateRequest, ConsistencyOptions?, CancellationToken)

public Task<UserResult> UpdateUserAsync(Username username, UserUpdateRequest body, ConsistencyOptions<UserResult>? consistency = null, CancellationToken ct = default)

Update user Updates a user.

ParameterTypeDescription
usernameUsername
bodyUserUpdateRequest
consistencyConsistencyOptions<UserResult>
ctCancellationToken

Returns: Task<UserResult>

Resources

DeployResourcesFromFilesAsync(string[], string?, CancellationToken)

public Task<ExtendedDeploymentResponse> DeployResourcesFromFilesAsync(string[] resourceFilePaths, string? tenantId = null, CancellationToken ct = default)

Deploy resources from local filesystem paths. Reads the specified files, infers MIME types from their extensions, and calls with the loaded content.

ParameterTypeDescription
resourceFilePathsString[]Absolute or relative file paths to BPMN, DMN, form, or resource files.
tenantIdStringOptional tenant ID for multi-tenant deployments.
ctCancellationTokenCancellation token.

Returns: Task<ExtendedDeploymentResponse> — An with typed access to deployed artifacts.

Example

static async Task DeployResourcesFromFilesExample()
{
using var client = Camunda.CreateClient();

var result = await client.DeployResourcesFromFilesAsync(
new[] { "order-process.bpmn", "email-connector.bpmn" }
);

Console.WriteLine($"Deployment key: {result.DeploymentKey}");
foreach (var process in result.Processes)
{
Console.WriteLine($" Process: {process.ProcessDefinitionId} v{process.ProcessDefinitionVersion}");
}
}

DeleteResourceAsync(ResourceKey, DeleteResourceRequest, CancellationToken)

public Task<DeleteResourceResponse> DeleteResourceAsync(ResourceKey resourceKey, DeleteResourceRequest body, CancellationToken ct = default)

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.

Once a resource has been deleted it cannot be recovered. If the resource needs to be available again, a new deployment of the resource is required.

By default, only the resource itself is deleted from the runtime state. To also delete the historic data associated with a resource, set the deleteHistory flag in the request body to true. The historic data is deleted asynchronously via a batch operation. The details of the created batch operation are included in the response. Note that history deletion is only supported for process resources; for other resource types this flag is ignored and no history will be deleted.

ParameterTypeDescription
resourceKeyResourceKey
bodyDeleteResourceRequest
ctCancellationToken

Returns: Task<DeleteResourceResponse>

Example

static async Task DeleteResourceExample()
{
using var client = Camunda.CreateClient();

// Deploy a resource and get its key from the deployment response
var deployment = await client.DeployResourcesFromFilesAsync(
new[] { "order-process.bpmn" }
);
// ProcessDefinitionKey doubles as the resource key for deletion
var resourceKey = ResourceKey.AssumeExists(deployment.Processes[0].ProcessDefinitionKey.Value);

await client.DeleteResourceAsync(resourceKey, new DeleteResourceRequest());
}

GetResourceAsync(ResourceKey, CancellationToken)

public Task<ResourceResult> GetResourceAsync(ResourceKey resourceKey, CancellationToken ct = default)

Get resource Returns a deployed resource.

info

Currently, this endpoint only supports RPA resources.

ParameterTypeDescription
resourceKeyResourceKey
ctCancellationToken

Returns: Task<ResourceResult>

GetResourceContentAsync(ResourceKey, CancellationToken)

public Task<object> GetResourceContentAsync(ResourceKey resourceKey, CancellationToken ct = default)

Get resource content Returns the content of a deployed resource.

info

Currently, this endpoint only supports RPA resources.

ParameterTypeDescription
resourceKeyResourceKey
ctCancellationToken

Returns: Task<Object>

Jobs

CreateJobWorker(JobWorkerConfig, JobHandler)

public JobWorker CreateJobWorker(JobWorkerConfig config, JobHandler handler)

Create a job worker that polls for and processes jobs of the specified type.

The handler receives an and returns variables to auto-complete. Throw for BPMN errors, for explicit failures, or any other exception to auto-fail with retries - 1.

ParameterTypeDescription
configJobWorkerConfigWorker configuration (job type, timeout, concurrency).
handlerJobHandlerAsync handler that processes each job. Return output variables (or null) to complete.

Returns: JobWorker — The running instance.

CreateJobWorker(JobWorkerConfig, Func<ActivatedJob, CancellationToken, Task>)

public JobWorker CreateJobWorker(JobWorkerConfig config, Func<ActivatedJob, CancellationToken, Task> handler)

Create a job worker with a handler that doesn't return output variables. The job is auto-completed with no variables on success.

ParameterTypeDescription
configJobWorkerConfig
handlerFunc<Task>

Returns: JobWorker

Example

#pragma warning disable CS1998 // Async method lacks await (handler is simple for demo purposes)
static async Task JobWorkerExample()
{
await using var client = Camunda.CreateClient();

client.CreateJobWorker(
new JobWorkerConfig
{
JobType = "send-email",
JobTimeoutMs = 300_000, // 5 minutes
MaxConcurrentJobs = 5,
PollIntervalMs = 5_000
},
async (job, ct) =>
{
var recipient = job.GetVariables<Dictionary<string, string>>()?
.GetValueOrDefault("recipient");
Console.WriteLine($"Sending email to {recipient}");
});

// Run all registered workers until cancelled
using var cts = new CancellationTokenSource();
await client.RunWorkersAsync(ct: cts.Token);
}

ActivateJobsAsync(JobActivationRequest, CancellationToken)

public Task<ActivateJobsResponse> ActivateJobsAsync(JobActivationRequest body, CancellationToken ct = default)

Activate jobs Iterate through all known partitions and activate jobs up to the requested maximum.

ParameterTypeDescription
bodyJobActivationRequest
ctCancellationToken

Returns: Task<ActivateJobsResponse>

Example

static async Task ActivateJobsExample()
{
using var client = Camunda.CreateClient();

var response = await client.ActivateJobsAsync(new JobActivationRequest
{
Type = "send-email",
MaxJobsToActivate = 10,
Timeout = 300_000, // 5 minutes
Worker = "email-worker-1"
});

foreach (var job in response.Jobs)
{
Console.WriteLine($"Job {job.JobKey}: {job.Type}");
}
}

CompleteJobAsync(JobKey, JobCompletionRequest, CancellationToken)

public Task CompleteJobAsync(JobKey jobKey, JobCompletionRequest body, CancellationToken ct = default)

Complete job Complete a job with the given payload, which allows completing the associated service task.

ParameterTypeDescription
jobKeyJobKey
bodyJobCompletionRequest
ctCancellationToken

Returns: Task

Example

static async Task CompleteJobExample()
{
using var client = Camunda.CreateClient();

// Activate jobs and get a JobKey from the response
var activated = await client.ActivateJobsAsync(new JobActivationRequest
{
Type = "send-email",
MaxJobsToActivate = 1,
Timeout = 300_000,
Worker = "email-worker-1"
});
var jobKey = activated.Jobs[0].JobKey;

await client.CompleteJobAsync(jobKey, new JobCompletionRequest
{
Variables = new Dictionary<string, object>
{
["emailSent"] = true
}
});
}

FailJobAsync(JobKey, JobFailRequest, CancellationToken)

public Task FailJobAsync(JobKey jobKey, JobFailRequest body, CancellationToken ct = default)

Fail job Mark the job as failed.

ParameterTypeDescription
jobKeyJobKey
bodyJobFailRequest
ctCancellationToken

Returns: Task

Example

static async Task FailJobExample()
{
using var client = Camunda.CreateClient();

// Activate a job and get its JobKey from the response
var activated = await client.ActivateJobsAsync(new JobActivationRequest
{
Type = "send-email",
MaxJobsToActivate = 1,
Timeout = 300_000,
Worker = "email-worker-1"
});
var jobKey = activated.Jobs[0].JobKey;

await client.FailJobAsync(jobKey, new JobFailRequest
{
Retries = 2,
ErrorMessage = "SMTP server unreachable",
RetryBackOff = 30_000 // 30 seconds
});
}

GetGlobalJobStatisticsAsync(DateTimeOffset, DateTimeOffset, string?, ConsistencyOptions?, CancellationToken)

public Task<GlobalJobStatisticsQueryResult> GetGlobalJobStatisticsAsync(DateTimeOffset from, DateTimeOffset to, string? jobType = null, ConsistencyOptions<GlobalJobStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Global job statistics Returns global aggregated counts for jobs. Optionally filter by the creation time window and/or jobType.

ParameterTypeDescription
fromDateTimeOffset
toDateTimeOffset
jobTypeString
consistencyConsistencyOptions<GlobalJobStatisticsQueryResult>
ctCancellationToken

Returns: Task<GlobalJobStatisticsQueryResult>

SearchJobsAsync(JobSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<SearchJobsResponse> SearchJobsAsync(JobSearchQuery body, ConsistencyOptions<SearchJobsResponse>? consistency = null, CancellationToken ct = default)

Search jobs Search for jobs based on given criteria.

ParameterTypeDescription
bodyJobSearchQuery
consistencyConsistencyOptions<SearchJobsResponse>
ctCancellationToken

Returns: Task<SearchJobsResponse>

Example

static async Task SearchJobsExample()
{
using var client = Camunda.CreateClient();

var result = await client.SearchJobsAsync(new JobSearchQuery());

foreach (var job in result.Items!)
{
Console.WriteLine($"Job {job.JobKey}: type={job.Type}, state={job.State}");
}
}

ThrowJobErrorAsync(JobKey, JobErrorRequest, CancellationToken)

public Task ThrowJobErrorAsync(JobKey jobKey, JobErrorRequest body, CancellationToken ct = default)

Throw error for job Reports a business error (i.e. non-technical) that occurs while processing a job.

ParameterTypeDescription
jobKeyJobKey
bodyJobErrorRequest
ctCancellationToken

Returns: Task

Example

static async Task ThrowJobErrorExample()
{
using var client = Camunda.CreateClient();

// Activate a job and get its JobKey from the response
var activated = await client.ActivateJobsAsync(new JobActivationRequest
{
Type = "send-email",
MaxJobsToActivate = 1,
Timeout = 300_000,
Worker = "email-worker-1"
});
var jobKey = activated.Jobs[0].JobKey;

await client.ThrowJobErrorAsync(jobKey, new JobErrorRequest
{
ErrorCode = "INVALID_ADDRESS",
ErrorMessage = "Recipient email address is invalid"
});
}

UpdateJobAsync(JobKey, JobUpdateRequest, CancellationToken)

public Task UpdateJobAsync(JobKey jobKey, JobUpdateRequest body, CancellationToken ct = default)

Update job Update a job with the given key.

ParameterTypeDescription
jobKeyJobKey
bodyJobUpdateRequest
ctCancellationToken

Returns: Task

Job Workers

RunWorkersAsync(TimeSpan?, CancellationToken)

public Task RunWorkersAsync(TimeSpan? gracePeriod = null, CancellationToken ct = default)

Block until cancellation is requested, keeping all registered workers alive. This is the typical entry point for worker-only applications.

When the token is cancelled, all workers are stopped gracefully.

ParameterTypeDescription
gracePeriodNullable<TimeSpan>Time to wait for in-flight jobs to finish during shutdown. Default: 10 seconds.
ctCancellationTokenCancellation token that signals shutdown.

Returns: Task

StopAllWorkersAsync(TimeSpan?)

public Task StopAllWorkersAsync(TimeSpan? gracePeriod = null)

Stop all registered workers and wait for in-flight jobs to drain.

ParameterTypeDescription
gracePeriodNullable<TimeSpan>

Returns: Task

GetWorkers()

public IReadOnlyList<JobWorker> GetWorkers()

Returns a snapshot of all registered workers.

Returns: IReadOnlyList<JobWorker>

Elements

ActivateAdHocSubProcessActivitiesAsync(ElementInstanceKey, AdHocSubProcessActivateActivitiesInstruction, CancellationToken)

public Task ActivateAdHocSubProcessActivitiesAsync(ElementInstanceKey adHocSubProcessInstanceKey, AdHocSubProcessActivateActivitiesInstruction body, CancellationToken ct = default)

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.

ParameterTypeDescription
adHocSubProcessInstanceKeyElementInstanceKey
bodyAdHocSubProcessActivateActivitiesInstruction
ctCancellationToken

Returns: Task

GetElementInstanceAsync(ElementInstanceKey, ConsistencyOptions?, CancellationToken)

public Task<GetElementInstanceResponse> GetElementInstanceAsync(ElementInstanceKey elementInstanceKey, ConsistencyOptions<GetElementInstanceResponse>? consistency = null, CancellationToken ct = default)

Get element instance Returns element instance as JSON.

ParameterTypeDescription
elementInstanceKeyElementInstanceKey
consistencyConsistencyOptions<GetElementInstanceResponse>
ctCancellationToken

Returns: Task<GetElementInstanceResponse>

SearchElementInstancesAsync(ElementInstanceSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<SearchElementInstancesResponse> SearchElementInstancesAsync(ElementInstanceSearchQuery body, ConsistencyOptions<SearchElementInstancesResponse>? consistency = null, CancellationToken ct = default)

Search element instances Search for element instances based on given criteria.

ParameterTypeDescription
bodyElementInstanceSearchQuery
consistencyConsistencyOptions<SearchElementInstancesResponse>
ctCancellationToken

Returns: Task<SearchElementInstancesResponse>

Groups

AssignClientToGroupAsync(string, string, CancellationToken)

public Task AssignClientToGroupAsync(string groupId, string clientId, CancellationToken ct = default)

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.

ParameterTypeDescription
groupIdString
clientIdString
ctCancellationToken

Returns: Task

AssignMappingRuleToGroupAsync(string, string, CancellationToken)

public Task AssignMappingRuleToGroupAsync(string groupId, string mappingRuleId, CancellationToken ct = default)

Assign a mapping rule to a group Assigns a mapping rule to a group.

ParameterTypeDescription
groupIdString
mappingRuleIdString
ctCancellationToken

Returns: Task

AssignUserToGroupAsync(string, Username, CancellationToken)

public Task AssignUserToGroupAsync(string groupId, Username username, CancellationToken ct = default)

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.

ParameterTypeDescription
groupIdString
usernameUsername
ctCancellationToken

Returns: Task

CreateGroupAsync(GroupCreateRequest, CancellationToken)

public Task<GroupCreateResult> CreateGroupAsync(GroupCreateRequest body, CancellationToken ct = default)

Create group Create a new group.

ParameterTypeDescription
bodyGroupCreateRequest
ctCancellationToken

Returns: Task<GroupCreateResult>

DeleteGroupAsync(string, CancellationToken)

public Task DeleteGroupAsync(string groupId, CancellationToken ct = default)

Delete group Deletes the group with the given ID.

ParameterTypeDescription
groupIdString
ctCancellationToken

Returns: Task

GetGroupAsync(string, ConsistencyOptions?, CancellationToken)

public Task<GroupResult> GetGroupAsync(string groupId, ConsistencyOptions<GroupResult>? consistency = null, CancellationToken ct = default)

Get group Get a group by its ID.

ParameterTypeDescription
groupIdString
consistencyConsistencyOptions<GroupResult>
ctCancellationToken

Returns: Task<GroupResult>

SearchGroupsAsync(GroupSearchQueryRequest, ConsistencyOptions?, CancellationToken)

public Task<GroupSearchQueryResult> SearchGroupsAsync(GroupSearchQueryRequest body, ConsistencyOptions<GroupSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search groups Search for groups based on given criteria.

ParameterTypeDescription
bodyGroupSearchQueryRequest
consistencyConsistencyOptions<GroupSearchQueryResult>
ctCancellationToken

Returns: Task<GroupSearchQueryResult>

SearchMappingRulesForGroupAsync(string, MappingRuleSearchQueryRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchQueryResponse> SearchMappingRulesForGroupAsync(string groupId, MappingRuleSearchQueryRequest body, ConsistencyOptions<SearchQueryResponse>? consistency = null, CancellationToken ct = default)

Search group mapping rules Search mapping rules assigned to a group.

ParameterTypeDescription
groupIdString
bodyMappingRuleSearchQueryRequest
consistencyConsistencyOptions<SearchQueryResponse>
ctCancellationToken

Returns: Task<SearchQueryResponse>

UnassignClientFromGroupAsync(string, string, CancellationToken)

public Task UnassignClientFromGroupAsync(string groupId, string clientId, CancellationToken ct = default)

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.

ParameterTypeDescription
groupIdString
clientIdString
ctCancellationToken

Returns: Task

UnassignMappingRuleFromGroupAsync(string, string, CancellationToken)

public Task UnassignMappingRuleFromGroupAsync(string groupId, string mappingRuleId, CancellationToken ct = default)

Unassign a mapping rule from a group Unassigns a mapping rule from a group.

ParameterTypeDescription
groupIdString
mappingRuleIdString
ctCancellationToken

Returns: Task

UnassignUserFromGroupAsync(string, Username, CancellationToken)

public Task UnassignUserFromGroupAsync(string groupId, Username username, CancellationToken ct = default)

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.

ParameterTypeDescription
groupIdString
usernameUsername
ctCancellationToken

Returns: Task

UpdateGroupAsync(string, GroupUpdateRequest, CancellationToken)

public Task<GroupUpdateResult> UpdateGroupAsync(string groupId, GroupUpdateRequest body, CancellationToken ct = default)

Update group Update a group with the given ID.

ParameterTypeDescription
groupIdString
bodyGroupUpdateRequest
ctCancellationToken

Returns: Task<GroupUpdateResult>

Tenants

AssignClientToTenantAsync(TenantId, string, CancellationToken)

public Task AssignClientToTenantAsync(TenantId tenantId, string clientId, CancellationToken ct = default)

Assign a client to a tenant Assign the client to the specified tenant. The client can then access tenant data and perform authorized actions.

ParameterTypeDescription
tenantIdTenantId
clientIdString
ctCancellationToken

Returns: Task

AssignGroupToTenantAsync(TenantId, string, CancellationToken)

public Task AssignGroupToTenantAsync(TenantId tenantId, string groupId, CancellationToken ct = default)

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.

ParameterTypeDescription
tenantIdTenantId
groupIdString
ctCancellationToken

Returns: Task

AssignMappingRuleToTenantAsync(TenantId, string, CancellationToken)

public Task AssignMappingRuleToTenantAsync(TenantId tenantId, string mappingRuleId, CancellationToken ct = default)

Assign a mapping rule to a tenant Assign a single mapping rule to a specified tenant.

ParameterTypeDescription
tenantIdTenantId
mappingRuleIdString
ctCancellationToken

Returns: Task

AssignRoleToTenantAsync(TenantId, string, CancellationToken)

public Task AssignRoleToTenantAsync(TenantId tenantId, string roleId, CancellationToken ct = default)

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.

ParameterTypeDescription
tenantIdTenantId
roleIdString
ctCancellationToken

Returns: Task

AssignUserToTenantAsync(TenantId, Username, CancellationToken)

public Task AssignUserToTenantAsync(TenantId tenantId, Username username, CancellationToken ct = default)

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.

ParameterTypeDescription
tenantIdTenantId
usernameUsername
ctCancellationToken

Returns: Task

CreateTenantAsync(TenantCreateRequest, CancellationToken)

public Task<TenantCreateResult> CreateTenantAsync(TenantCreateRequest body, CancellationToken ct = default)

Create tenant Creates a new tenant.

ParameterTypeDescription
bodyTenantCreateRequest
ctCancellationToken

Returns: Task<TenantCreateResult>

DeleteTenantAsync(TenantId, CancellationToken)

public Task DeleteTenantAsync(TenantId tenantId, CancellationToken ct = default)

Delete tenant Deletes an existing tenant.

ParameterTypeDescription
tenantIdTenantId
ctCancellationToken

Returns: Task

GetTenantAsync(TenantId, ConsistencyOptions?, CancellationToken)

public Task<TenantResult> GetTenantAsync(TenantId tenantId, ConsistencyOptions<TenantResult>? consistency = null, CancellationToken ct = default)

Get tenant Retrieves a single tenant by tenant ID.

ParameterTypeDescription
tenantIdTenantId
consistencyConsistencyOptions<TenantResult>
ctCancellationToken

Returns: Task<TenantResult>

GetUsageMetricsAsync(DateTimeOffset, DateTimeOffset, TenantId?, bool?, ConsistencyOptions?, CancellationToken)

public Task<UsageMetricsResponse> GetUsageMetricsAsync(DateTimeOffset startTime, DateTimeOffset endTime, TenantId? tenantId = null, bool? withTenants = null, ConsistencyOptions<UsageMetricsResponse>? consistency = null, CancellationToken ct = default)

Get usage metrics Retrieve the usage metrics based on given criteria.

ParameterTypeDescription
startTimeDateTimeOffset
endTimeDateTimeOffset
tenantIdNullable<TenantId>
withTenantsNullable<Boolean>
consistencyConsistencyOptions<UsageMetricsResponse>
ctCancellationToken

Returns: Task<UsageMetricsResponse>

SearchClientsForGroupAsync(string, SearchClientsForGroupRequest, ConsistencyOptions?, CancellationToken)

public Task<TenantClientSearchResult> SearchClientsForGroupAsync(string groupId, SearchClientsForGroupRequest body, ConsistencyOptions<TenantClientSearchResult>? consistency = null, CancellationToken ct = default)

Search group clients Search clients assigned to a group.

ParameterTypeDescription
groupIdString
bodySearchClientsForGroupRequest
consistencyConsistencyOptions<TenantClientSearchResult>
ctCancellationToken

Returns: Task<TenantClientSearchResult>

SearchClientsForRoleAsync(string, SearchClientsForRoleRequest, ConsistencyOptions?, CancellationToken)

public Task<TenantClientSearchResult> SearchClientsForRoleAsync(string roleId, SearchClientsForRoleRequest body, ConsistencyOptions<TenantClientSearchResult>? consistency = null, CancellationToken ct = default)

Search role clients Search clients with assigned role.

ParameterTypeDescription
roleIdString
bodySearchClientsForRoleRequest
consistencyConsistencyOptions<TenantClientSearchResult>
ctCancellationToken

Returns: Task<TenantClientSearchResult>

SearchClientsForTenantAsync(TenantId, SearchClientsForTenantRequest, ConsistencyOptions?, CancellationToken)

public Task<TenantClientSearchResult> SearchClientsForTenantAsync(TenantId tenantId, SearchClientsForTenantRequest body, ConsistencyOptions<TenantClientSearchResult>? consistency = null, CancellationToken ct = default)

Search clients for tenant Retrieves a filtered and sorted list of clients for a specified tenant.

ParameterTypeDescription
tenantIdTenantId
bodySearchClientsForTenantRequest
consistencyConsistencyOptions<TenantClientSearchResult>
ctCancellationToken

Returns: Task<TenantClientSearchResult>

SearchGroupIdsForTenantAsync(TenantId, SearchGroupIdsForTenantRequest, ConsistencyOptions?, CancellationToken)

public Task<TenantGroupSearchResult> SearchGroupIdsForTenantAsync(TenantId tenantId, SearchGroupIdsForTenantRequest body, ConsistencyOptions<TenantGroupSearchResult>? consistency = null, CancellationToken ct = default)

Search groups for tenant Retrieves a filtered and sorted list of groups for a specified tenant.

ParameterTypeDescription
tenantIdTenantId
bodySearchGroupIdsForTenantRequest
consistencyConsistencyOptions<TenantGroupSearchResult>
ctCancellationToken

Returns: Task<TenantGroupSearchResult>

SearchMappingRulesForTenantAsync(TenantId, MappingRuleSearchQueryRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchQueryResponse> SearchMappingRulesForTenantAsync(TenantId tenantId, MappingRuleSearchQueryRequest body, ConsistencyOptions<SearchQueryResponse>? consistency = null, CancellationToken ct = default)

Search mapping rules for tenant Retrieves a filtered and sorted list of MappingRules for a specified tenant.

ParameterTypeDescription
tenantIdTenantId
bodyMappingRuleSearchQueryRequest
consistencyConsistencyOptions<SearchQueryResponse>
ctCancellationToken

Returns: Task<SearchQueryResponse>

SearchRolesForTenantAsync(TenantId, RoleSearchQueryRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchQueryResponse> SearchRolesForTenantAsync(TenantId tenantId, RoleSearchQueryRequest body, ConsistencyOptions<SearchQueryResponse>? consistency = null, CancellationToken ct = default)

Search roles for tenant Retrieves a filtered and sorted list of roles for a specified tenant.

ParameterTypeDescription
tenantIdTenantId
bodyRoleSearchQueryRequest
consistencyConsistencyOptions<SearchQueryResponse>
ctCancellationToken

Returns: Task<SearchQueryResponse>

SearchTenantsAsync(SearchTenantsRequest, ConsistencyOptions?, CancellationToken)

public Task<TenantSearchQueryResult> SearchTenantsAsync(SearchTenantsRequest body, ConsistencyOptions<TenantSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search tenants Retrieves a filtered and sorted list of tenants.

ParameterTypeDescription
bodySearchTenantsRequest
consistencyConsistencyOptions<TenantSearchQueryResult>
ctCancellationToken

Returns: Task<TenantSearchQueryResult>

SearchUsersForGroupAsync(string, SearchUsersForGroupRequest, ConsistencyOptions?, CancellationToken)

public Task<TenantUserSearchResult> SearchUsersForGroupAsync(string groupId, SearchUsersForGroupRequest body, ConsistencyOptions<TenantUserSearchResult>? consistency = null, CancellationToken ct = default)

Search group users Search users assigned to a group.

ParameterTypeDescription
groupIdString
bodySearchUsersForGroupRequest
consistencyConsistencyOptions<TenantUserSearchResult>
ctCancellationToken

Returns: Task<TenantUserSearchResult>

SearchUsersForRoleAsync(string, SearchUsersForRoleRequest, ConsistencyOptions?, CancellationToken)

public Task<TenantUserSearchResult> SearchUsersForRoleAsync(string roleId, SearchUsersForRoleRequest body, ConsistencyOptions<TenantUserSearchResult>? consistency = null, CancellationToken ct = default)

Search role users Search users with assigned role.

ParameterTypeDescription
roleIdString
bodySearchUsersForRoleRequest
consistencyConsistencyOptions<TenantUserSearchResult>
ctCancellationToken

Returns: Task<TenantUserSearchResult>

SearchUsersForTenantAsync(TenantId, SearchUsersForTenantRequest, ConsistencyOptions?, CancellationToken)

public Task<TenantUserSearchResult> SearchUsersForTenantAsync(TenantId tenantId, SearchUsersForTenantRequest body, ConsistencyOptions<TenantUserSearchResult>? consistency = null, CancellationToken ct = default)

Search users for tenant Retrieves a filtered and sorted list of users for a specified tenant.

ParameterTypeDescription
tenantIdTenantId
bodySearchUsersForTenantRequest
consistencyConsistencyOptions<TenantUserSearchResult>
ctCancellationToken

Returns: Task<TenantUserSearchResult>

UnassignClientFromTenantAsync(TenantId, string, CancellationToken)

public Task UnassignClientFromTenantAsync(TenantId tenantId, string clientId, CancellationToken ct = default)

Unassign a client from a tenant Unassigns the client from the specified tenant. The client can no longer access tenant data.

ParameterTypeDescription
tenantIdTenantId
clientIdString
ctCancellationToken

Returns: Task

UnassignGroupFromTenantAsync(TenantId, string, CancellationToken)

public Task UnassignGroupFromTenantAsync(TenantId tenantId, string groupId, CancellationToken ct = default)

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.

ParameterTypeDescription
tenantIdTenantId
groupIdString
ctCancellationToken

Returns: Task

UnassignMappingRuleFromTenantAsync(TenantId, string, CancellationToken)

public Task UnassignMappingRuleFromTenantAsync(TenantId tenantId, string mappingRuleId, CancellationToken ct = default)

Unassign a mapping rule from a tenant Unassigns a single mapping rule from a specified tenant without deleting the rule.

ParameterTypeDescription
tenantIdTenantId
mappingRuleIdString
ctCancellationToken

Returns: Task

UnassignRoleFromTenantAsync(TenantId, string, CancellationToken)

public Task UnassignRoleFromTenantAsync(TenantId tenantId, string roleId, CancellationToken ct = default)

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.

ParameterTypeDescription
tenantIdTenantId
roleIdString
ctCancellationToken

Returns: Task

UnassignUserFromTenantAsync(TenantId, Username, CancellationToken)

public Task UnassignUserFromTenantAsync(TenantId tenantId, Username username, CancellationToken ct = default)

Unassign a user from a tenant Unassigns the user from the specified tenant. The user can no longer access tenant data.

ParameterTypeDescription
tenantIdTenantId
usernameUsername
ctCancellationToken

Returns: Task

UpdateTenantAsync(TenantId, TenantUpdateRequest, CancellationToken)

public Task<TenantUpdateResult> UpdateTenantAsync(TenantId tenantId, TenantUpdateRequest body, CancellationToken ct = default)

Update tenant Updates an existing tenant.

ParameterTypeDescription
tenantIdTenantId
bodyTenantUpdateRequest
ctCancellationToken

Returns: Task<TenantUpdateResult>

Roles

AssignRoleToClientAsync(string, string, CancellationToken)

public Task AssignRoleToClientAsync(string roleId, string clientId, CancellationToken ct = default)

Assign a role to a client Assigns the specified role to the client. The client will inherit the authorizations associated with this role.

ParameterTypeDescription
roleIdString
clientIdString
ctCancellationToken

Returns: Task

AssignRoleToGroupAsync(string, string, CancellationToken)

public Task AssignRoleToGroupAsync(string roleId, string groupId, CancellationToken ct = default)

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.

ParameterTypeDescription
roleIdString
groupIdString
ctCancellationToken

Returns: Task

AssignRoleToMappingRuleAsync(string, string, CancellationToken)

public Task AssignRoleToMappingRuleAsync(string roleId, string mappingRuleId, CancellationToken ct = default)

Assign a role to a mapping rule Assigns a role to a mapping rule.

ParameterTypeDescription
roleIdString
mappingRuleIdString
ctCancellationToken

Returns: Task

AssignRoleToUserAsync(string, Username, CancellationToken)

public Task AssignRoleToUserAsync(string roleId, Username username, CancellationToken ct = default)

Assign a role to a user Assigns the specified role to the user. The user will inherit the authorizations associated with this role.

ParameterTypeDescription
roleIdString
usernameUsername
ctCancellationToken

Returns: Task

CreateRoleAsync(RoleCreateRequest, CancellationToken)

public Task<RoleCreateResult> CreateRoleAsync(RoleCreateRequest body, CancellationToken ct = default)

Create role Create a new role.

ParameterTypeDescription
bodyRoleCreateRequest
ctCancellationToken

Returns: Task<RoleCreateResult>

DeleteRoleAsync(string, CancellationToken)

public Task DeleteRoleAsync(string roleId, CancellationToken ct = default)

Delete role Deletes the role with the given ID.

ParameterTypeDescription
roleIdString
ctCancellationToken

Returns: Task

GetRoleAsync(string, ConsistencyOptions?, CancellationToken)

public Task<RoleResult> GetRoleAsync(string roleId, ConsistencyOptions<RoleResult>? consistency = null, CancellationToken ct = default)

Get role Get a role by its ID.

ParameterTypeDescription
roleIdString
consistencyConsistencyOptions<RoleResult>
ctCancellationToken

Returns: Task<RoleResult>

SearchGroupsForRoleAsync(string, SearchGroupsForRoleRequest, ConsistencyOptions?, CancellationToken)

public Task<RoleGroupSearchResult> SearchGroupsForRoleAsync(string roleId, SearchGroupsForRoleRequest body, ConsistencyOptions<RoleGroupSearchResult>? consistency = null, CancellationToken ct = default)

Search role groups Search groups with assigned role.

ParameterTypeDescription
roleIdString
bodySearchGroupsForRoleRequest
consistencyConsistencyOptions<RoleGroupSearchResult>
ctCancellationToken

Returns: Task<RoleGroupSearchResult>

SearchMappingRulesForRoleAsync(string, MappingRuleSearchQueryRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchQueryResponse> SearchMappingRulesForRoleAsync(string roleId, MappingRuleSearchQueryRequest body, ConsistencyOptions<SearchQueryResponse>? consistency = null, CancellationToken ct = default)

Search role mapping rules Search mapping rules with assigned role.

ParameterTypeDescription
roleIdString
bodyMappingRuleSearchQueryRequest
consistencyConsistencyOptions<SearchQueryResponse>
ctCancellationToken

Returns: Task<SearchQueryResponse>

SearchRolesAsync(RoleSearchQueryRequest, ConsistencyOptions?, CancellationToken)

public Task<RoleSearchQueryResult> SearchRolesAsync(RoleSearchQueryRequest body, ConsistencyOptions<RoleSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search roles Search for roles based on given criteria.

ParameterTypeDescription
bodyRoleSearchQueryRequest
consistencyConsistencyOptions<RoleSearchQueryResult>
ctCancellationToken

Returns: Task<RoleSearchQueryResult>

SearchRolesForGroupAsync(string, RoleSearchQueryRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchQueryResponse> SearchRolesForGroupAsync(string groupId, RoleSearchQueryRequest body, ConsistencyOptions<SearchQueryResponse>? consistency = null, CancellationToken ct = default)

Search group roles Search roles assigned to a group.

ParameterTypeDescription
groupIdString
bodyRoleSearchQueryRequest
consistencyConsistencyOptions<SearchQueryResponse>
ctCancellationToken

Returns: Task<SearchQueryResponse>

UnassignRoleFromClientAsync(string, string, CancellationToken)

public Task UnassignRoleFromClientAsync(string roleId, string clientId, CancellationToken ct = default)

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.

ParameterTypeDescription
roleIdString
clientIdString
ctCancellationToken

Returns: Task

UnassignRoleFromGroupAsync(string, string, CancellationToken)

public Task UnassignRoleFromGroupAsync(string roleId, string groupId, CancellationToken ct = default)

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.

ParameterTypeDescription
roleIdString
groupIdString
ctCancellationToken

Returns: Task

UnassignRoleFromMappingRuleAsync(string, string, CancellationToken)

public Task UnassignRoleFromMappingRuleAsync(string roleId, string mappingRuleId, CancellationToken ct = default)

Unassign a role from a mapping rule Unassigns a role from a mapping rule.

ParameterTypeDescription
roleIdString
mappingRuleIdString
ctCancellationToken

Returns: Task

UnassignRoleFromUserAsync(string, Username, CancellationToken)

public Task UnassignRoleFromUserAsync(string roleId, Username username, CancellationToken ct = default)

Unassign a role from a user Unassigns a role from a user. The user will no longer inherit the authorizations associated with this role.

ParameterTypeDescription
roleIdString
usernameUsername
ctCancellationToken

Returns: Task

UpdateRoleAsync(string, RoleUpdateRequest, CancellationToken)

public Task<RoleUpdateResult> UpdateRoleAsync(string roleId, RoleUpdateRequest body, CancellationToken ct = default)

Update role Update a role with the given ID.

ParameterTypeDescription
roleIdString
bodyRoleUpdateRequest
ctCancellationToken

Returns: Task<RoleUpdateResult>

User Tasks

AssignUserTaskAsync(UserTaskKey, UserTaskAssignmentRequest, CancellationToken)

public Task AssignUserTaskAsync(UserTaskKey userTaskKey, UserTaskAssignmentRequest body, CancellationToken ct = default)

Assign user task Assigns a user task with the given key to the given assignee.

ParameterTypeDescription
userTaskKeyUserTaskKey
bodyUserTaskAssignmentRequest
ctCancellationToken

Returns: Task

Example

static async Task AssignUserTaskExample()
{
using var client = Camunda.CreateClient();

// Find a user task via search
var tasks = await client.SearchUserTasksAsync(new SearchUserTasksRequest());
var userTaskKey = tasks.Items![0].UserTaskKey.Value;

await client.AssignUserTaskAsync(userTaskKey, new UserTaskAssignmentRequest
{
Assignee = "jane.doe"
});
}

CompleteUserTaskAsync(UserTaskKey, UserTaskCompletionRequest, CancellationToken)

public Task CompleteUserTaskAsync(UserTaskKey userTaskKey, UserTaskCompletionRequest body, CancellationToken ct = default)

Complete user task Completes a user task with the given key.

ParameterTypeDescription
userTaskKeyUserTaskKey
bodyUserTaskCompletionRequest
ctCancellationToken

Returns: Task

Example

static async Task CompleteUserTaskExample()
{
using var client = Camunda.CreateClient();

// Find a user task via search
var tasks = await client.SearchUserTasksAsync(new SearchUserTasksRequest());
var userTaskKey = tasks.Items![0].UserTaskKey.Value;

await client.CompleteUserTaskAsync(userTaskKey, new UserTaskCompletionRequest
{
Variables = new Dictionary<string, object>
{
["approved"] = true,
["comment"] = "Looks good"
}
});
}

GetUserTaskAsync(UserTaskKey, ConsistencyOptions?, CancellationToken)

public Task<GetUserTaskResponse> GetUserTaskAsync(UserTaskKey userTaskKey, ConsistencyOptions<GetUserTaskResponse>? consistency = null, CancellationToken ct = default)

Get user task Get the user task by the user task key.

ParameterTypeDescription
userTaskKeyUserTaskKey
consistencyConsistencyOptions<GetUserTaskResponse>
ctCancellationToken

Returns: Task<GetUserTaskResponse>

GetUserTaskFormAsync(UserTaskKey, ConsistencyOptions?, CancellationToken)

public Task<GetUserTaskFormResponse> GetUserTaskFormAsync(UserTaskKey userTaskKey, ConsistencyOptions<GetUserTaskFormResponse>? consistency = null, CancellationToken ct = default)

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.

ParameterTypeDescription
userTaskKeyUserTaskKey
consistencyConsistencyOptions<GetUserTaskFormResponse>
ctCancellationToken

Returns: Task<GetUserTaskFormResponse>

SearchUserTaskAuditLogsAsync(UserTaskKey, SearchUserTaskAuditLogsRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchUserTaskAuditLogsResponse> SearchUserTaskAuditLogsAsync(UserTaskKey userTaskKey, SearchUserTaskAuditLogsRequest body, ConsistencyOptions<SearchUserTaskAuditLogsResponse>? consistency = null, CancellationToken ct = default)

Search user task audit logs Search for user task audit logs based on given criteria.

ParameterTypeDescription
userTaskKeyUserTaskKey
bodySearchUserTaskAuditLogsRequest
consistencyConsistencyOptions<SearchUserTaskAuditLogsResponse>
ctCancellationToken

Returns: Task<SearchUserTaskAuditLogsResponse>

SearchUserTaskVariablesAsync(UserTaskKey, SearchUserTaskVariablesRequest, bool?, ConsistencyOptions?, CancellationToken)

public Task<SearchUserTaskVariablesResponse> SearchUserTaskVariablesAsync(UserTaskKey userTaskKey, SearchUserTaskVariablesRequest body, bool? truncateValues = null, ConsistencyOptions<SearchUserTaskVariablesResponse>? consistency = null, CancellationToken ct = default)

Search user task variables Search for user task variables based on given criteria. By default, long variable values in the response are truncated.

ParameterTypeDescription
userTaskKeyUserTaskKey
bodySearchUserTaskVariablesRequest
truncateValuesNullable<Boolean>
consistencyConsistencyOptions<SearchUserTaskVariablesResponse>
ctCancellationToken

Returns: Task<SearchUserTaskVariablesResponse>

SearchUserTasksAsync(SearchUserTasksRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchUserTasksResponse> SearchUserTasksAsync(SearchUserTasksRequest body, ConsistencyOptions<SearchUserTasksResponse>? consistency = null, CancellationToken ct = default)

Search user tasks Search for user tasks based on given criteria.

ParameterTypeDescription
bodySearchUserTasksRequest
consistencyConsistencyOptions<SearchUserTasksResponse>
ctCancellationToken

Returns: Task<SearchUserTasksResponse>

Example

static async Task SearchUserTasksExample()
{
using var client = Camunda.CreateClient();

var result = await client.SearchUserTasksAsync(new SearchUserTasksRequest());

foreach (var task in result.Items!)
{
Console.WriteLine($"Task {task.UserTaskKey}: {task.State}, assignee={task.Assignee}");
}
}

UnassignUserTaskAsync(UserTaskKey, CancellationToken)

public Task UnassignUserTaskAsync(UserTaskKey userTaskKey, CancellationToken ct = default)

Unassign user task Removes the assignee of a task with the given key.

ParameterTypeDescription
userTaskKeyUserTaskKey
ctCancellationToken

Returns: Task

Example

static async Task UnassignUserTaskExample()
{
using var client = Camunda.CreateClient();

// Find a user task via search
var tasks = await client.SearchUserTasksAsync(new SearchUserTasksRequest());
var userTaskKey = tasks.Items![0].UserTaskKey.Value;

await client.UnassignUserTaskAsync(userTaskKey);
}

UpdateUserTaskAsync(UserTaskKey, UserTaskUpdateRequest, CancellationToken)

public Task UpdateUserTaskAsync(UserTaskKey userTaskKey, UserTaskUpdateRequest body, CancellationToken ct = default)

Update user task Update a user task with the given key.

ParameterTypeDescription
userTaskKeyUserTaskKey
bodyUserTaskUpdateRequest
ctCancellationToken

Returns: Task

Example

static async Task UpdateUserTaskExample()
{
using var client = Camunda.CreateClient();

// Find a user task via search
var tasks = await client.SearchUserTasksAsync(new SearchUserTasksRequest());
var userTaskKey = tasks.Items![0].UserTaskKey.Value;

await client.UpdateUserTaskAsync(userTaskKey, new UserTaskUpdateRequest
{
Changeset = new Changeset
{
DueDate = DateTimeOffset.UtcNow.AddDays(3),
Priority = 80
}
});
}

Signals

BroadcastSignalAsync(SignalBroadcastRequest, CancellationToken)

public Task<SignalBroadcastResult> BroadcastSignalAsync(SignalBroadcastRequest body, CancellationToken ct = default)

Broadcast signal Broadcasts a signal.

ParameterTypeDescription
bodySignalBroadcastRequest
ctCancellationToken

Returns: Task<SignalBroadcastResult>

Example

static async Task BroadcastSignalExample()
{
using var client = Camunda.CreateClient();

var result = await client.BroadcastSignalAsync(new SignalBroadcastRequest
{
SignalName = "system-shutdown",
Variables = new Dictionary<string, object>
{
["reason"] = "maintenance"
}
});

Console.WriteLine($"Signal key: {result.SignalKey}");
}

Batch Operations

CancelBatchOperationAsync(BatchOperationKey, ConsistencyOptions?, CancellationToken)
public Task CancelBatchOperationAsync(BatchOperationKey batchOperationKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

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}).

ParameterTypeDescription
batchOperationKeyBatchOperationKey
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task

GetBatchOperationAsync(BatchOperationKey, ConsistencyOptions?, CancellationToken)

public Task<BatchOperationResponse> GetBatchOperationAsync(BatchOperationKey batchOperationKey, ConsistencyOptions<BatchOperationResponse>? consistency = null, CancellationToken ct = default)

Get batch operation Get batch operation by key.

ParameterTypeDescription
batchOperationKeyBatchOperationKey
consistencyConsistencyOptions<BatchOperationResponse>
ctCancellationToken

Returns: Task<BatchOperationResponse>

ResumeBatchOperationAsync(BatchOperationKey, ConsistencyOptions?, CancellationToken)
public Task ResumeBatchOperationAsync(BatchOperationKey batchOperationKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

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}).

ParameterTypeDescription
batchOperationKeyBatchOperationKey
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task

SearchBatchOperationItemsAsync(SearchBatchOperationItemsRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchBatchOperationItemsResponse> SearchBatchOperationItemsAsync(SearchBatchOperationItemsRequest body, ConsistencyOptions<SearchBatchOperationItemsResponse>? consistency = null, CancellationToken ct = default)

Search batch operation items Search for batch operation items based on given criteria.

ParameterTypeDescription
bodySearchBatchOperationItemsRequest
consistencyConsistencyOptions<SearchBatchOperationItemsResponse>
ctCancellationToken

Returns: Task<SearchBatchOperationItemsResponse>

SearchBatchOperationsAsync(SearchBatchOperationsRequest, ConsistencyOptions?, CancellationToken)

public Task<BatchOperationSearchQueryResult> SearchBatchOperationsAsync(SearchBatchOperationsRequest body, ConsistencyOptions<BatchOperationSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search batch operations Search for batch operations based on given criteria.

ParameterTypeDescription
bodySearchBatchOperationsRequest
consistencyConsistencyOptions<BatchOperationSearchQueryResult>
ctCancellationToken

Returns: Task<BatchOperationSearchQueryResult>

SuspendBatchOperationAsync(BatchOperationKey, ConsistencyOptions?, CancellationToken)
public Task SuspendBatchOperationAsync(BatchOperationKey batchOperationKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

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}).

ParameterTypeDescription
batchOperationKeyBatchOperationKey
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task

Process Instances

CancelProcessInstanceAsync(ProcessInstanceKey, CancelProcessInstanceRequest, CancellationToken)

public Task CancelProcessInstanceAsync(ProcessInstanceKey processInstanceKey, CancelProcessInstanceRequest body, CancellationToken ct = default)

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.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
bodyCancelProcessInstanceRequest
ctCancellationToken

Returns: Task

Example

static async Task CancelProcessInstanceExample()
{
using var client = Camunda.CreateClient();

// Create a process instance and get its key from the response
var created = await client.CreateProcessInstanceAsync(new ProcessInstanceCreationInstructionById
{
ProcessDefinitionId = ProcessDefinitionId.AssumeExists("order-process"),
});

// Cancel the process instance using the key from the creation response
await client.CancelProcessInstanceAsync(created.ProcessInstanceKey, new CancelProcessInstanceRequest());
}

CancelProcessInstancesBatchOperationAsync(CancelProcessInstancesBatchOperationRequest, ConsistencyOptions?, CancellationToken)

public Task<BatchOperationCreatedResult> CancelProcessInstancesBatchOperationAsync(CancelProcessInstancesBatchOperationRequest body, ConsistencyOptions<BatchOperationCreatedResult>? consistency = null, CancellationToken ct = default)

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. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

ParameterTypeDescription
bodyCancelProcessInstancesBatchOperationRequest
consistencyConsistencyOptions<BatchOperationCreatedResult>
ctCancellationToken

Returns: Task<BatchOperationCreatedResult>

CreateProcessInstanceAsync(ProcessInstanceCreationInstruction, CancellationToken)

public Task<CreateProcessInstanceResult> CreateProcessInstanceAsync(ProcessInstanceCreationInstruction body, CancellationToken ct = default)

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.

Waits for the completion of the process instance before returning a result when awaitCompletion is enabled.

ParameterTypeDescription
bodyProcessInstanceCreationInstruction
ctCancellationToken

Returns: Task<CreateProcessInstanceResult>

Example

static async Task CreateProcessInstanceExample()
{
using var client = Camunda.CreateClient();

// Deploy a process and retrieve its ProcessDefinitionId
var deployment = await client.DeployResourcesFromFilesAsync(
new[] { "order-process.bpmn" }
);
var processDefinitionId = deployment.Processes[0].ProcessDefinitionId;

// Start a new instance using the deployed process definition
var result = await client.CreateProcessInstanceAsync(new ProcessInstanceCreationInstructionById
{
ProcessDefinitionId = processDefinitionId,
});

Console.WriteLine($"Started process instance: {result.ProcessInstanceKey}");
}

DeleteDecisionInstanceAsync(DecisionInstanceKey, DeleteProcessInstanceRequest, ConsistencyOptions?, CancellationToken)
public Task DeleteDecisionInstanceAsync(DecisionInstanceKey decisionInstanceKey, DeleteProcessInstanceRequest body, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Delete decision instance Delete all associated decision evaluations based on provided key.

ParameterTypeDescription
decisionInstanceKeyDecisionInstanceKey
bodyDeleteProcessInstanceRequest
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task

DeleteProcessInstanceAsync(ProcessInstanceKey, DeleteProcessInstanceRequest, ConsistencyOptions?, CancellationToken)
public Task DeleteProcessInstanceAsync(ProcessInstanceKey processInstanceKey, DeleteProcessInstanceRequest body, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Delete process instance Deletes a process instance. Only instances that are completed or terminated can be deleted.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
bodyDeleteProcessInstanceRequest
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task

DeleteProcessInstancesBatchOperationAsync(DeleteProcessInstancesBatchOperationRequest, ConsistencyOptions?, CancellationToken)

public Task<BatchOperationCreatedResult> DeleteProcessInstancesBatchOperationAsync(DeleteProcessInstancesBatchOperationRequest body, ConsistencyOptions<BatchOperationCreatedResult>? consistency = null, CancellationToken ct = default)

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}).

ParameterTypeDescription
bodyDeleteProcessInstancesBatchOperationRequest
consistencyConsistencyOptions<BatchOperationCreatedResult>
ctCancellationToken

Returns: Task<BatchOperationCreatedResult>

GetProcessInstanceAsync(ProcessInstanceKey, ConsistencyOptions?, CancellationToken)

public Task<GetProcessInstanceResponse> GetProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<GetProcessInstanceResponse>? consistency = null, CancellationToken ct = default)

Get process instance Get the process instance by the process instance key.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
consistencyConsistencyOptions<GetProcessInstanceResponse>
ctCancellationToken

Returns: Task<GetProcessInstanceResponse>

GetProcessInstanceCallHierarchyAsync(ProcessInstanceKey, ConsistencyOptions?, CancellationToken)
public Task<object> GetProcessInstanceCallHierarchyAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get call hierarchy Returns the call hierarchy for a given process instance, showing its ancestry up to the root instance.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task<Object>

GetProcessInstanceSequenceFlowsAsync(ProcessInstanceKey, ConsistencyOptions?, CancellationToken)

public Task<GetProcessInstanceSequenceFlowsResponse> GetProcessInstanceSequenceFlowsAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<GetProcessInstanceSequenceFlowsResponse>? consistency = null, CancellationToken ct = default)

Get sequence flows Get sequence flows taken by the process instance.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
consistencyConsistencyOptions<GetProcessInstanceSequenceFlowsResponse>
ctCancellationToken

Returns: Task<GetProcessInstanceSequenceFlowsResponse>

GetProcessInstanceStatisticsAsync(ProcessInstanceKey, ConsistencyOptions?, CancellationToken)

public Task<ProcessInstanceElementStatisticsQueryResult> GetProcessInstanceStatisticsAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<ProcessInstanceElementStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get element instance statistics Get statistics about elements by the process instance key.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
consistencyConsistencyOptions<ProcessInstanceElementStatisticsQueryResult>
ctCancellationToken

Returns: Task<ProcessInstanceElementStatisticsQueryResult>

GetProcessInstanceStatisticsByDefinitionAsync(IncidentProcessInstanceStatisticsByDefinitionQuery, ConsistencyOptions?, CancellationToken)

public Task<IncidentProcessInstanceStatisticsByDefinitionQueryResult> GetProcessInstanceStatisticsByDefinitionAsync(IncidentProcessInstanceStatisticsByDefinitionQuery body, ConsistencyOptions<IncidentProcessInstanceStatisticsByDefinitionQueryResult>? consistency = null, CancellationToken ct = default)

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.

ParameterTypeDescription
bodyIncidentProcessInstanceStatisticsByDefinitionQuery
consistencyConsistencyOptions<IncidentProcessInstanceStatisticsByDefinitionQueryResult>
ctCancellationToken

Returns: Task<IncidentProcessInstanceStatisticsByDefinitionQueryResult>

GetProcessInstanceStatisticsByErrorAsync(IncidentProcessInstanceStatisticsByErrorQuery, ConsistencyOptions?, CancellationToken)

public Task<IncidentProcessInstanceStatisticsByErrorQueryResult> GetProcessInstanceStatisticsByErrorAsync(IncidentProcessInstanceStatisticsByErrorQuery body, ConsistencyOptions<IncidentProcessInstanceStatisticsByErrorQueryResult>? consistency = null, CancellationToken ct = default)

Get process instance statistics by error Returns statistics for active process instances that currently have active incidents, grouped by incident error hash code.

ParameterTypeDescription
bodyIncidentProcessInstanceStatisticsByErrorQuery
consistencyConsistencyOptions<IncidentProcessInstanceStatisticsByErrorQueryResult>
ctCancellationToken

Returns: Task<IncidentProcessInstanceStatisticsByErrorQueryResult>

MigrateProcessInstanceAsync(ProcessInstanceKey, MigrateProcessInstanceRequest, CancellationToken)

public Task MigrateProcessInstanceAsync(ProcessInstanceKey processInstanceKey, MigrateProcessInstanceRequest body, CancellationToken ct = default)

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.

Use this to upgrade a process instance to a new version of a process or to a different process definition, e.g. to keep your running instances up-to-date with the latest process improvements.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
bodyMigrateProcessInstanceRequest
ctCancellationToken

Returns: Task

Example

static async Task MigrateProcessInstanceExample()
{
using var client = Camunda.CreateClient();

// Create an instance to migrate
var created = await client.CreateProcessInstanceAsync(new ProcessInstanceCreationInstructionById
{
ProcessDefinitionId = ProcessDefinitionId.AssumeExists("order-process"),
});

// Deploy the updated process version and get its ProcessDefinitionKey
var v2 = await client.DeployResourcesFromFilesAsync(
new[] { "order-process-v2.bpmn" }
);
var targetProcessDefinitionKey = v2.Processes[0].ProcessDefinitionKey;

await client.MigrateProcessInstanceAsync(created.ProcessInstanceKey, new MigrateProcessInstanceRequest
{
TargetProcessDefinitionKey = targetProcessDefinitionKey,
MappingInstructions = new List<MigrateProcessInstanceMappingInstruction>
{
new()
{
SourceElementId = ElementId.AssumeExists("taskA"),
TargetElementId = ElementId.AssumeExists("taskB"),
}
}
});
}

MigrateProcessInstancesBatchOperationAsync(MigrateProcessInstancesBatchOperationRequest, ConsistencyOptions?, CancellationToken)

public Task<BatchOperationCreatedResult> MigrateProcessInstancesBatchOperationAsync(MigrateProcessInstancesBatchOperationRequest body, ConsistencyOptions<BatchOperationCreatedResult>? consistency = null, CancellationToken ct = default)

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. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

ParameterTypeDescription
bodyMigrateProcessInstancesBatchOperationRequest
consistencyConsistencyOptions<BatchOperationCreatedResult>
ctCancellationToken

Returns: Task<BatchOperationCreatedResult>

ModifyProcessInstanceAsync(ProcessInstanceKey, ModifyProcessInstanceRequest, CancellationToken)

public Task ModifyProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ModifyProcessInstanceRequest body, CancellationToken ct = default)

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.

Use this to repair a process instance that is stuck on an element or took an unintended path. For example, because an external system is not available or doesn't respond as expected.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
bodyModifyProcessInstanceRequest
ctCancellationToken

Returns: Task

Example

static async Task ModifyProcessInstanceExample()
{
using var client = Camunda.CreateClient();

// Get a ProcessInstanceKey from the creation response
var created = await client.CreateProcessInstanceAsync(new ProcessInstanceCreationInstructionById
{
ProcessDefinitionId = ProcessDefinitionId.AssumeExists("order-process"),
});

await client.ModifyProcessInstanceAsync(created.ProcessInstanceKey, new ModifyProcessInstanceRequest
{
ActivateInstructions = new List<ProcessInstanceModificationActivateInstruction>
{
new() { ElementId = ElementId.AssumeExists("taskB") }
}
});
}

ModifyProcessInstancesBatchOperationAsync(ModifyProcessInstancesBatchOperationRequest, ConsistencyOptions?, CancellationToken)

public Task<BatchOperationCreatedResult> ModifyProcessInstancesBatchOperationAsync(ModifyProcessInstancesBatchOperationRequest body, ConsistencyOptions<BatchOperationCreatedResult>? consistency = null, CancellationToken ct = default)

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. In contrast to single modification operation, it is not possible to add variable instructions or modify by element key. It is only possible to use the element id of the source and target. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

ParameterTypeDescription
bodyModifyProcessInstancesBatchOperationRequest
consistencyConsistencyOptions<BatchOperationCreatedResult>
ctCancellationToken

Returns: Task<BatchOperationCreatedResult>

ResolveProcessInstanceIncidentsAsync(ProcessInstanceKey, ConsistencyOptions?, CancellationToken)

public Task<BatchOperationCreatedResult> ResolveProcessInstanceIncidentsAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<BatchOperationCreatedResult>? consistency = null, CancellationToken ct = default)

Resolve related incidents Creates a batch operation to resolve multiple incidents of a process instance.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
consistencyConsistencyOptions<BatchOperationCreatedResult>
ctCancellationToken

Returns: Task<BatchOperationCreatedResult>

SearchProcessInstanceIncidentsAsync(ProcessInstanceKey, IncidentSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<SearchProcessInstanceIncidentsResponse> SearchProcessInstanceIncidentsAsync(ProcessInstanceKey processInstanceKey, IncidentSearchQuery body, ConsistencyOptions<SearchProcessInstanceIncidentsResponse>? consistency = null, CancellationToken ct = default)

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, you may also include a processInstanceKey within the filter object to narrow results to specific child process instances. This is useful, for example, if you want to isolate incidents associated with subprocesses or called processes under the root instance while excluding incidents directly tied to the root.

ParameterTypeDescription
processInstanceKeyProcessInstanceKey
bodyIncidentSearchQuery
consistencyConsistencyOptions<SearchProcessInstanceIncidentsResponse>
ctCancellationToken

Returns: Task<SearchProcessInstanceIncidentsResponse>

SearchProcessInstancesAsync(SearchProcessInstancesRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchProcessInstancesResponse> SearchProcessInstancesAsync(SearchProcessInstancesRequest body, ConsistencyOptions<SearchProcessInstancesResponse>? consistency = null, CancellationToken ct = default)

Search process instances Search for process instances based on given criteria.

ParameterTypeDescription
bodySearchProcessInstancesRequest
consistencyConsistencyOptions<SearchProcessInstancesResponse>
ctCancellationToken

Returns: Task<SearchProcessInstancesResponse>

Example

static async Task SearchProcessInstancesExample()
{
using var client = Camunda.CreateClient();

var result = await client.SearchProcessInstancesAsync(new SearchProcessInstancesRequest());

foreach (var instance in result.Items)
{
Console.WriteLine($"{instance.ProcessInstanceKey}{instance.State}");
}
}

Messages

CorrelateMessageAsync(MessageCorrelationRequest, CancellationToken)

public Task<MessageCorrelationResult> CorrelateMessageAsync(MessageCorrelationRequest body, CancellationToken ct = default)

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. Use the publish message endpoint to send messages that can be buffered.

ParameterTypeDescription
bodyMessageCorrelationRequest
ctCancellationToken

Returns: Task<MessageCorrelationResult>

Example

static async Task CorrelateMessageExample()
{
using var client = Camunda.CreateClient();

var result = await client.CorrelateMessageAsync(new MessageCorrelationRequest
{
Name = "payment-received",
CorrelationKey = "ORD-12345",
Variables = new Dictionary<string, object>
{
["paymentId"] = "PAY-98765",
["amount"] = 99.95
}
});

Console.WriteLine($"Message key: {result.MessageKey}");
}

PublishMessageAsync(MessagePublicationRequest, CancellationToken)

public Task<PublishMessageResponse> PublishMessageAsync(MessagePublicationRequest body, CancellationToken ct = default)

Publish message Publishes a single message. Messages are published to specific partitions computed from their correlation keys. Messages can be buffered. The endpoint does not wait for a correlation result. Use the message correlation endpoint for such use cases.

ParameterTypeDescription
bodyMessagePublicationRequest
ctCancellationToken

Returns: Task<PublishMessageResponse>

Example

static async Task PublishMessageExample()
{
using var client = Camunda.CreateClient();

await client.PublishMessageAsync(new MessagePublicationRequest
{
Name = "order-placed",
CorrelationKey = "ORD-12345",
TimeToLive = 60_000, // 1 minute
Variables = new Dictionary<string, object>
{
["orderId"] = "ORD-12345"
}
});
}

SearchCorrelatedMessageSubscriptionsAsync(CorrelatedMessageSubscriptionSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<SearchCorrelatedMessageSubscriptionsResponse> SearchCorrelatedMessageSubscriptionsAsync(CorrelatedMessageSubscriptionSearchQuery body, ConsistencyOptions<SearchCorrelatedMessageSubscriptionsResponse>? consistency = null, CancellationToken ct = default)

Search correlated message subscriptions Search correlated message subscriptions based on given criteria.

ParameterTypeDescription
bodyCorrelatedMessageSubscriptionSearchQuery
consistencyConsistencyOptions<SearchCorrelatedMessageSubscriptionsResponse>
ctCancellationToken

Returns: Task<SearchCorrelatedMessageSubscriptionsResponse>

SearchMessageSubscriptionsAsync(SearchMessageSubscriptionsRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchMessageSubscriptionsResponse> SearchMessageSubscriptionsAsync(SearchMessageSubscriptionsRequest body, ConsistencyOptions<SearchMessageSubscriptionsResponse>? consistency = null, CancellationToken ct = default)

Search message subscriptions Search for message subscriptions based on given criteria.

ParameterTypeDescription
bodySearchMessageSubscriptionsRequest
consistencyConsistencyOptions<SearchMessageSubscriptionsResponse>
ctCancellationToken

Returns: Task<SearchMessageSubscriptionsResponse>

Authorizations

CreateAuthorizationAsync(AuthorizationRequest, CancellationToken)

public Task<AuthorizationCreateResult> CreateAuthorizationAsync(AuthorizationRequest body, CancellationToken ct = default)

Create authorization Create the authorization.

ParameterTypeDescription
bodyAuthorizationRequest
ctCancellationToken

Returns: Task<AuthorizationCreateResult>

DeleteAuthorizationAsync(AuthorizationKey, CancellationToken)

public Task DeleteAuthorizationAsync(AuthorizationKey authorizationKey, CancellationToken ct = default)

Delete authorization Deletes the authorization with the given key.

ParameterTypeDescription
authorizationKeyAuthorizationKey
ctCancellationToken

Returns: Task

GetAuthorizationAsync(AuthorizationKey, ConsistencyOptions?, CancellationToken)

public Task<AuthorizationResult> GetAuthorizationAsync(AuthorizationKey authorizationKey, ConsistencyOptions<AuthorizationResult>? consistency = null, CancellationToken ct = default)

Get authorization Get authorization by the given key.

ParameterTypeDescription
authorizationKeyAuthorizationKey
consistencyConsistencyOptions<AuthorizationResult>
ctCancellationToken

Returns: Task<AuthorizationResult>

SearchAuthorizationsAsync(AuthorizationSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<AuthorizationSearchResult> SearchAuthorizationsAsync(AuthorizationSearchQuery body, ConsistencyOptions<AuthorizationSearchResult>? consistency = null, CancellationToken ct = default)

Search authorizations Search for authorizations based on given criteria.

ParameterTypeDescription
bodyAuthorizationSearchQuery
consistencyConsistencyOptions<AuthorizationSearchResult>
ctCancellationToken

Returns: Task<AuthorizationSearchResult>

UpdateAuthorizationAsync(AuthorizationKey, AuthorizationRequest, CancellationToken)

public Task UpdateAuthorizationAsync(AuthorizationKey authorizationKey, AuthorizationRequest body, CancellationToken ct = default)

Update authorization Update the authorization with the given key.

ParameterTypeDescription
authorizationKeyAuthorizationKey
bodyAuthorizationRequest
ctCancellationToken

Returns: Task

Deployments

CreateDeploymentAsync(MultipartFormDataContent, CancellationToken)

public Task<CreateDeploymentResponse> CreateDeploymentAsync(MultipartFormDataContent content, CancellationToken ct = default)

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.

ParameterTypeDescription
contentMultipartFormDataContent
ctCancellationToken

Returns: Task<CreateDeploymentResponse>

Documents

CreateDocumentAsync(MultipartFormDataContent, string?, DocumentId?, CancellationToken)

public Task<DocumentReference> CreateDocumentAsync(MultipartFormDataContent content, string? storeId = null, DocumentId? documentId = null, CancellationToken ct = default)

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)

ParameterTypeDescription
contentMultipartFormDataContent
storeIdString
documentIdNullable<DocumentId>
ctCancellationToken

Returns: Task<DocumentReference>

CreateDocumentLinkAsync(DocumentId, DocumentLinkRequest, string?, string?, CancellationToken)

public Task<DocumentLink> CreateDocumentLinkAsync(DocumentId documentId, DocumentLinkRequest body, string? storeId = null, string? contentHash = null, CancellationToken ct = default)

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

ParameterTypeDescription
documentIdDocumentId
bodyDocumentLinkRequest
storeIdString
contentHashString
ctCancellationToken

Returns: Task<DocumentLink>

CreateDocumentsAsync(MultipartFormDataContent, string?, CancellationToken)

public Task<DocumentCreationBatchResponse> CreateDocumentsAsync(MultipartFormDataContent content, string? storeId = null, CancellationToken ct = default)

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 to identify which documents failed to upload. The file name can be provided in the Content-Disposition header of the file part or in the fileName field of the metadata. You can add a parallel array of metadata objects. These are matched with the files based on index, and must have the same length as the files array. To pass homogenous metadata for all files, spread the metadata over the metadata array. A filename value provided explicitly via the metadata array in the request overrides the Content-Disposition header of the file part.

In case of a multi-status response, the response body will contain a list of DocumentBatchProblemDetail objects, each of which contains the file name of the document that failed to upload and the reason for the failure. The client can choose to retry the whole batch or individual documents based on the response.

Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)

ParameterTypeDescription
contentMultipartFormDataContent
storeIdString
ctCancellationToken

Returns: Task<DocumentCreationBatchResponse>

DeleteDocumentAsync(DocumentId, string?, CancellationToken)

public Task DeleteDocumentAsync(DocumentId documentId, string? storeId = null, CancellationToken ct = default)

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)

ParameterTypeDescription
documentIdDocumentId
storeIdString
ctCancellationToken

Returns: Task

GetDocumentAsync(DocumentId, string?, string?, CancellationToken)

public Task<object> GetDocumentAsync(DocumentId documentId, string? storeId = null, string? contentHash = null, CancellationToken ct = default)

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)

ParameterTypeDescription
documentIdDocumentId
storeIdString
contentHashString
ctCancellationToken

Returns: Task<Object>

Variables

CreateElementInstanceVariablesAsync(ElementInstanceKey, SetVariableRequest, CancellationToken)

public Task CreateElementInstanceVariablesAsync(ElementInstanceKey elementInstanceKey, SetVariableRequest body, CancellationToken ct = default)

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.

ParameterTypeDescription
elementInstanceKeyElementInstanceKey
bodySetVariableRequest
ctCancellationToken

Returns: Task

CreateGlobalClusterVariableAsync(CreateClusterVariableRequest, CancellationToken)

public Task<ClusterVariableResult> CreateGlobalClusterVariableAsync(CreateClusterVariableRequest body, CancellationToken ct = default)

Create a global-scoped cluster variable

ParameterTypeDescription
bodyCreateClusterVariableRequest
ctCancellationToken

Returns: Task<ClusterVariableResult>

CreateTenantClusterVariableAsync(TenantId, CreateClusterVariableRequest, CancellationToken)

public Task<ClusterVariableResult> CreateTenantClusterVariableAsync(TenantId tenantId, CreateClusterVariableRequest body, CancellationToken ct = default)

Create a tenant-scoped cluster variable

ParameterTypeDescription
tenantIdTenantId
bodyCreateClusterVariableRequest
ctCancellationToken

Returns: Task<ClusterVariableResult>

DeleteGlobalClusterVariableAsync(string, CancellationToken)

public Task DeleteGlobalClusterVariableAsync(string name, CancellationToken ct = default)

Delete a global-scoped cluster variable

ParameterTypeDescription
nameString
ctCancellationToken

Returns: Task

DeleteTenantClusterVariableAsync(TenantId, string, CancellationToken)

public Task DeleteTenantClusterVariableAsync(TenantId tenantId, string name, CancellationToken ct = default)

Delete a tenant-scoped cluster variable

ParameterTypeDescription
tenantIdTenantId
nameString
ctCancellationToken

Returns: Task

GetGlobalClusterVariableAsync(string, ConsistencyOptions?, CancellationToken)

public Task<ClusterVariableResult> GetGlobalClusterVariableAsync(string name, ConsistencyOptions<ClusterVariableResult>? consistency = null, CancellationToken ct = default)

Get a global-scoped cluster variable

ParameterTypeDescription
nameString
consistencyConsistencyOptions<ClusterVariableResult>
ctCancellationToken

Returns: Task<ClusterVariableResult>

GetTenantClusterVariableAsync(TenantId, string, ConsistencyOptions?, CancellationToken)

public Task<ClusterVariableResult> GetTenantClusterVariableAsync(TenantId tenantId, string name, ConsistencyOptions<ClusterVariableResult>? consistency = null, CancellationToken ct = default)

Get a tenant-scoped cluster variable

ParameterTypeDescription
tenantIdTenantId
nameString
consistencyConsistencyOptions<ClusterVariableResult>
ctCancellationToken

Returns: Task<ClusterVariableResult>

GetVariableAsync(VariableKey, ConsistencyOptions?, CancellationToken)

public Task<GetVariableResponse> GetVariableAsync(VariableKey variableKey, ConsistencyOptions<GetVariableResponse>? consistency = null, CancellationToken ct = default)

Get variable Get the variable by the variable key.

ParameterTypeDescription
variableKeyVariableKey
consistencyConsistencyOptions<GetVariableResponse>
ctCancellationToken

Returns: Task<GetVariableResponse>

SearchClusterVariablesAsync(ClusterVariableSearchQueryRequest, bool?, ConsistencyOptions?, CancellationToken)

public Task<ClusterVariableSearchQueryResult> SearchClusterVariablesAsync(ClusterVariableSearchQueryRequest body, bool? truncateValues = null, ConsistencyOptions<ClusterVariableSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search for cluster variables based on given criteria. By default, long variable values in the response are truncated.

ParameterTypeDescription
bodyClusterVariableSearchQueryRequest
truncateValuesNullable<Boolean>
consistencyConsistencyOptions<ClusterVariableSearchQueryResult>
ctCancellationToken

Returns: Task<ClusterVariableSearchQueryResult>

SearchVariablesAsync(SearchVariablesRequest, bool?, ConsistencyOptions?, CancellationToken)

public Task<SearchVariablesResponse> SearchVariablesAsync(SearchVariablesRequest body, bool? truncateValues = null, ConsistencyOptions<SearchVariablesResponse>? consistency = null, CancellationToken ct = default)

Search variables Search for process and local variables based on given criteria. By default, long variable values in the response are truncated.

ParameterTypeDescription
bodySearchVariablesRequest
truncateValuesNullable<Boolean>
consistencyConsistencyOptions<SearchVariablesResponse>
ctCancellationToken

Returns: Task<SearchVariablesResponse>

UpdateGlobalClusterVariableAsync(string, UpdateClusterVariableRequest, CancellationToken)

public Task<ClusterVariableResult> UpdateGlobalClusterVariableAsync(string name, UpdateClusterVariableRequest body, CancellationToken ct = default)

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.

ParameterTypeDescription
nameString
bodyUpdateClusterVariableRequest
ctCancellationToken

Returns: Task<ClusterVariableResult>

UpdateTenantClusterVariableAsync(TenantId, string, UpdateClusterVariableRequest, CancellationToken)

public Task<ClusterVariableResult> UpdateTenantClusterVariableAsync(TenantId tenantId, string name, UpdateClusterVariableRequest body, CancellationToken ct = default)

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.

ParameterTypeDescription
tenantIdTenantId
nameString
bodyUpdateClusterVariableRequest
ctCancellationToken

Returns: Task<ClusterVariableResult>

Mappings

CreateMappingRuleAsync(MappingRuleCreateRequest, CancellationToken)

public Task<MappingRuleUpdateResult> CreateMappingRuleAsync(MappingRuleCreateRequest body, CancellationToken ct = default)

Create mapping rule Create a new mapping rule

ParameterTypeDescription
bodyMappingRuleCreateRequest
ctCancellationToken

Returns: Task<MappingRuleUpdateResult>

DeleteMappingRuleAsync(string, CancellationToken)

public Task DeleteMappingRuleAsync(string mappingRuleId, CancellationToken ct = default)

Delete a mapping rule Deletes the mapping rule with the given ID.

ParameterTypeDescription
mappingRuleIdString
ctCancellationToken

Returns: Task

GetMappingRuleAsync(string, ConsistencyOptions?, CancellationToken)

public Task<MappingRuleResult> GetMappingRuleAsync(string mappingRuleId, ConsistencyOptions<MappingRuleResult>? consistency = null, CancellationToken ct = default)

Get a mapping rule Gets the mapping rule with the given ID.

ParameterTypeDescription
mappingRuleIdString
consistencyConsistencyOptions<MappingRuleResult>
ctCancellationToken

Returns: Task<MappingRuleResult>

SearchMappingRuleAsync(MappingRuleSearchQueryRequest, ConsistencyOptions?, CancellationToken)

public Task<MappingRuleSearchQueryResult> SearchMappingRuleAsync(MappingRuleSearchQueryRequest body, ConsistencyOptions<MappingRuleSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search mapping rules Search for mapping rules based on given criteria.

ParameterTypeDescription
bodyMappingRuleSearchQueryRequest
consistencyConsistencyOptions<MappingRuleSearchQueryResult>
ctCancellationToken

Returns: Task<MappingRuleSearchQueryResult>

UpdateMappingRuleAsync(string, MappingRuleUpdateRequest, CancellationToken)

public Task<MappingRuleUpdateResult> UpdateMappingRuleAsync(string mappingRuleId, MappingRuleUpdateRequest body, CancellationToken ct = default)

Update mapping rule Update a mapping rule.

ParameterTypeDescription
mappingRuleIdString
bodyMappingRuleUpdateRequest
ctCancellationToken

Returns: Task<MappingRuleUpdateResult>

Decision Instances

DeleteDecisionInstancesBatchOperationAsync(DecisionInstanceDeletionBatchOperationRequest, ConsistencyOptions?, CancellationToken)

public Task<BatchOperationCreatedResult> DeleteDecisionInstancesBatchOperationAsync(DecisionInstanceDeletionBatchOperationRequest body, ConsistencyOptions<BatchOperationCreatedResult>? consistency = null, CancellationToken ct = default)

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}).

ParameterTypeDescription
bodyDecisionInstanceDeletionBatchOperationRequest
consistencyConsistencyOptions<BatchOperationCreatedResult>
ctCancellationToken

Returns: Task<BatchOperationCreatedResult>

GetDecisionInstanceAsync(DecisionInstanceKey, ConsistencyOptions?, CancellationToken)
public Task<object> GetDecisionInstanceAsync(DecisionInstanceKey decisionEvaluationInstanceKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get decision instance Returns a decision instance.

ParameterTypeDescription
decisionEvaluationInstanceKeyDecisionInstanceKey
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task<Object>

SearchDecisionInstancesAsync(DecisionInstanceSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<SearchDecisionInstancesResponse> SearchDecisionInstancesAsync(DecisionInstanceSearchQuery body, ConsistencyOptions<SearchDecisionInstancesResponse>? consistency = null, CancellationToken ct = default)

Search decision instances Search for decision instances based on given criteria.

ParameterTypeDescription
bodyDecisionInstanceSearchQuery
consistencyConsistencyOptions<SearchDecisionInstancesResponse>
ctCancellationToken

Returns: Task<SearchDecisionInstancesResponse>

Decisions

EvaluateDecisionAsync(DecisionEvaluationInstruction, CancellationToken)

public Task<EvaluateDecisionResult> EvaluateDecisionAsync(DecisionEvaluationInstruction body, CancellationToken ct = default)

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 version of the decision is used.

ParameterTypeDescription
bodyDecisionEvaluationInstruction
ctCancellationToken

Returns: Task<EvaluateDecisionResult>

Example

static async Task EvaluateDecisionExample()
{
using var client = Camunda.CreateClient();

// Find the decision definition via search
var definitions = await client.SearchDecisionDefinitionsAsync(new DecisionDefinitionSearchQuery());
var decisionDefinitionId = definitions.Items![0].DecisionDefinitionId.Value;

var result = await client.EvaluateDecisionAsync(new DecisionEvaluationById
{
DecisionDefinitionId = decisionDefinitionId,
Variables = new Dictionary<string, object>
{
["weight"] = 5.2,
["destination"] = "DE"
}
});

Console.WriteLine($"Decision: {result.DecisionDefinitionId}");
}

Audit Logs

GetAuditLogAsync(AuditLogKey, ConsistencyOptions?, CancellationToken)

public Task<GetAuditLogResponse> GetAuditLogAsync(AuditLogKey auditLogKey, ConsistencyOptions<GetAuditLogResponse>? consistency = null, CancellationToken ct = default)

Get audit log Get an audit log entry by auditLogKey.

ParameterTypeDescription
auditLogKeyAuditLogKey
consistencyConsistencyOptions<GetAuditLogResponse>
ctCancellationToken

Returns: Task<GetAuditLogResponse>

SearchAuditLogsAsync(AuditLogSearchQueryRequest, ConsistencyOptions?, CancellationToken)

public Task<SearchAuditLogsResponse> SearchAuditLogsAsync(AuditLogSearchQueryRequest body, ConsistencyOptions<SearchAuditLogsResponse>? consistency = null, CancellationToken ct = default)

Search audit logs Search for audit logs based on given criteria.

ParameterTypeDescription
bodyAuditLogSearchQueryRequest
consistencyConsistencyOptions<SearchAuditLogsResponse>
ctCancellationToken

Returns: Task<SearchAuditLogsResponse>

Decision Definitions

GetDecisionDefinitionAsync(DecisionDefinitionKey, ConsistencyOptions?, CancellationToken)

public Task<DecisionDefinitionResult> GetDecisionDefinitionAsync(DecisionDefinitionKey decisionDefinitionKey, ConsistencyOptions<DecisionDefinitionResult>? consistency = null, CancellationToken ct = default)

Get decision definition Returns a decision definition by key.

ParameterTypeDescription
decisionDefinitionKeyDecisionDefinitionKey
consistencyConsistencyOptions<DecisionDefinitionResult>
ctCancellationToken

Returns: Task<DecisionDefinitionResult>

GetDecisionDefinitionXmlAsync(DecisionDefinitionKey, ConsistencyOptions?, CancellationToken)
public Task<object> GetDecisionDefinitionXmlAsync(DecisionDefinitionKey decisionDefinitionKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get decision definition XML Returns decision definition as XML.

ParameterTypeDescription
decisionDefinitionKeyDecisionDefinitionKey
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task<Object>

SearchDecisionDefinitionsAsync(DecisionDefinitionSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<DecisionDefinitionSearchQueryResult> SearchDecisionDefinitionsAsync(DecisionDefinitionSearchQuery body, ConsistencyOptions<DecisionDefinitionSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search decision definitions Search for decision definitions based on given criteria.

ParameterTypeDescription
bodyDecisionDefinitionSearchQuery
consistencyConsistencyOptions<DecisionDefinitionSearchQueryResult>
ctCancellationToken

Returns: Task<DecisionDefinitionSearchQueryResult>

Example

static async Task SearchDecisionDefinitionsExample()
{
using var client = Camunda.CreateClient();

var result = await client.SearchDecisionDefinitionsAsync(new DecisionDefinitionSearchQuery());

foreach (var def in result.Items!)
{
Console.WriteLine($"{def.DecisionDefinitionId} v{def.Version}");
}
}

Decision Requirements

GetDecisionRequirementsAsync(DecisionRequirementsKey, ConsistencyOptions?, CancellationToken)

public Task<DecisionRequirementsResult> GetDecisionRequirementsAsync(DecisionRequirementsKey decisionRequirementsKey, ConsistencyOptions<DecisionRequirementsResult>? consistency = null, CancellationToken ct = default)

Get decision requirements Returns Decision Requirements as JSON.

ParameterTypeDescription
decisionRequirementsKeyDecisionRequirementsKey
consistencyConsistencyOptions<DecisionRequirementsResult>
ctCancellationToken

Returns: Task<DecisionRequirementsResult>

GetDecisionRequirementsXmlAsync(DecisionRequirementsKey, ConsistencyOptions?, CancellationToken)
public Task<object> GetDecisionRequirementsXmlAsync(DecisionRequirementsKey decisionRequirementsKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get decision requirements XML Returns decision requirements as XML.

ParameterTypeDescription
decisionRequirementsKeyDecisionRequirementsKey
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task<Object>

SearchDecisionRequirementsAsync(DecisionRequirementsSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<DecisionRequirementsSearchQueryResult> SearchDecisionRequirementsAsync(DecisionRequirementsSearchQuery body, ConsistencyOptions<DecisionRequirementsSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search decision requirements Search for decision requirements based on given criteria.

ParameterTypeDescription
bodyDecisionRequirementsSearchQuery
consistencyConsistencyOptions<DecisionRequirementsSearchQueryResult>
ctCancellationToken

Returns: Task<DecisionRequirementsSearchQueryResult>

Incidents

GetIncidentAsync(IncidentKey, ConsistencyOptions?, CancellationToken)

public Task<GetIncidentResponse> GetIncidentAsync(IncidentKey incidentKey, ConsistencyOptions<GetIncidentResponse>? consistency = null, CancellationToken ct = default)

Get incident Returns incident as JSON.

ParameterTypeDescription
incidentKeyIncidentKey
consistencyConsistencyOptions<GetIncidentResponse>
ctCancellationToken

Returns: Task<GetIncidentResponse>

Example

static async Task GetIncidentExample()
{
using var client = Camunda.CreateClient();

// Find an incident via search
var incidents = await client.SearchIncidentsAsync(new IncidentSearchQuery());
var incidentKey = incidents.Items![0].IncidentKey.Value;

var incident = await client.GetIncidentAsync(incidentKey);

Console.WriteLine($"Incident {incident.IncidentKey}: {incident.ErrorType}");
Console.WriteLine($"Message: {incident.ErrorMessage}");
}

ResolveIncidentAsync(IncidentKey, IncidentResolutionRequest, CancellationToken)

public Task ResolveIncidentAsync(IncidentKey incidentKey, IncidentResolutionRequest body, CancellationToken ct = default)

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.

ParameterTypeDescription
incidentKeyIncidentKey
bodyIncidentResolutionRequest
ctCancellationToken

Returns: Task

Example

static async Task ResolveIncidentExample()
{
using var client = Camunda.CreateClient();

// Find an incident via search
var incidents = await client.SearchIncidentsAsync(new IncidentSearchQuery());
var incidentKey = incidents.Items![0].IncidentKey.Value;

await client.ResolveIncidentAsync(incidentKey, new IncidentResolutionRequest());
}

ResolveIncidentsBatchOperationAsync(ResolveIncidentsBatchOperationRequest, ConsistencyOptions?, CancellationToken)

public Task<BatchOperationCreatedResult> ResolveIncidentsBatchOperationAsync(ResolveIncidentsBatchOperationRequest body, ConsistencyOptions<BatchOperationCreatedResult>? consistency = null, CancellationToken ct = default)

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. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

ParameterTypeDescription
bodyResolveIncidentsBatchOperationRequest
consistencyConsistencyOptions<BatchOperationCreatedResult>
ctCancellationToken

Returns: Task<BatchOperationCreatedResult>

SearchElementInstanceIncidentsAsync(ElementInstanceKey, IncidentSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<SearchElementInstanceIncidentsResponse> SearchElementInstanceIncidentsAsync(ElementInstanceKey elementInstanceKey, IncidentSearchQuery body, ConsistencyOptions<SearchElementInstanceIncidentsResponse>? consistency = null, CancellationToken ct = default)

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, you may also include an elementInstanceKey within the filter object to narrow results to specific child element instances. This is useful, for example, if you want to isolate incidents associated with nested or subordinate elements within the given element instance while excluding incidents directly tied to the root element itself.

ParameterTypeDescription
elementInstanceKeyElementInstanceKey
bodyIncidentSearchQuery
consistencyConsistencyOptions<SearchElementInstanceIncidentsResponse>
ctCancellationToken

Returns: Task<SearchElementInstanceIncidentsResponse>

SearchIncidentsAsync(IncidentSearchQuery, ConsistencyOptions?, CancellationToken)

public Task<SearchIncidentsResponse> SearchIncidentsAsync(IncidentSearchQuery body, ConsistencyOptions<SearchIncidentsResponse>? consistency = null, CancellationToken ct = default)

Search incidents Search for incidents based on given criteria.

ParameterTypeDescription
bodyIncidentSearchQuery
consistencyConsistencyOptions<SearchIncidentsResponse>
ctCancellationToken

Returns: Task<SearchIncidentsResponse>

Example

static async Task SearchIncidentsExample()
{
using var client = Camunda.CreateClient();

var result = await client.SearchIncidentsAsync(new IncidentSearchQuery());

foreach (var incident in result.Items!)
{
Console.WriteLine($"Incident {incident.IncidentKey}: {incident.ErrorType}{incident.ErrorMessage}");
}
}

Process Definitions

GetProcessDefinitionAsync(ProcessDefinitionKey, ConsistencyOptions?, CancellationToken)

public Task<ProcessDefinitionResult> GetProcessDefinitionAsync(ProcessDefinitionKey processDefinitionKey, ConsistencyOptions<ProcessDefinitionResult>? consistency = null, CancellationToken ct = default)

Get process definition Returns process definition as JSON.

ParameterTypeDescription
processDefinitionKeyProcessDefinitionKey
consistencyConsistencyOptions<ProcessDefinitionResult>
ctCancellationToken

Returns: Task<ProcessDefinitionResult>

GetProcessDefinitionInstanceStatisticsAsync(ProcessDefinitionInstanceStatisticsQuery, ConsistencyOptions?, CancellationToken)

public Task<ProcessDefinitionInstanceStatisticsQueryResult> GetProcessDefinitionInstanceStatisticsAsync(ProcessDefinitionInstanceStatisticsQuery body, ConsistencyOptions<ProcessDefinitionInstanceStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get process instance statistics Get statistics about process instances, grouped by process definition and tenant.

ParameterTypeDescription
bodyProcessDefinitionInstanceStatisticsQuery
consistencyConsistencyOptions<ProcessDefinitionInstanceStatisticsQueryResult>
ctCancellationToken

Returns: Task<ProcessDefinitionInstanceStatisticsQueryResult>

GetProcessDefinitionInstanceVersionStatisticsAsync(ProcessDefinitionInstanceVersionStatisticsQuery, ConsistencyOptions?, CancellationToken)

public Task<ProcessDefinitionInstanceVersionStatisticsQueryResult> GetProcessDefinitionInstanceVersionStatisticsAsync(ProcessDefinitionInstanceVersionStatisticsQuery body, ConsistencyOptions<ProcessDefinitionInstanceVersionStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

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.

ParameterTypeDescription
bodyProcessDefinitionInstanceVersionStatisticsQuery
consistencyConsistencyOptions<ProcessDefinitionInstanceVersionStatisticsQueryResult>
ctCancellationToken

Returns: Task<ProcessDefinitionInstanceVersionStatisticsQueryResult>

GetProcessDefinitionMessageSubscriptionStatisticsAsync(ProcessDefinitionMessageSubscriptionStatisticsQuery, ConsistencyOptions?, CancellationToken)

public Task<ProcessDefinitionMessageSubscriptionStatisticsQueryResult> GetProcessDefinitionMessageSubscriptionStatisticsAsync(ProcessDefinitionMessageSubscriptionStatisticsQuery body, ConsistencyOptions<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get message subscription statistics Get message subscription statistics, grouped by process definition.

ParameterTypeDescription
bodyProcessDefinitionMessageSubscriptionStatisticsQuery
consistencyConsistencyOptions<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>
ctCancellationToken

Returns: Task<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>

GetProcessDefinitionStatisticsAsync(ProcessDefinitionKey, GetProcessDefinitionStatisticsRequest, ConsistencyOptions?, CancellationToken)

public Task<ProcessDefinitionElementStatisticsQueryResult> GetProcessDefinitionStatisticsAsync(ProcessDefinitionKey processDefinitionKey, GetProcessDefinitionStatisticsRequest body, ConsistencyOptions<ProcessDefinitionElementStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get process definition statistics Get statistics about elements in currently running process instances by process definition key and search filter.

ParameterTypeDescription
processDefinitionKeyProcessDefinitionKey
bodyGetProcessDefinitionStatisticsRequest
consistencyConsistencyOptions<ProcessDefinitionElementStatisticsQueryResult>
ctCancellationToken

Returns: Task<ProcessDefinitionElementStatisticsQueryResult>

GetProcessDefinitionXmlAsync(ProcessDefinitionKey, ConsistencyOptions?, CancellationToken)
public Task<object> GetProcessDefinitionXmlAsync(ProcessDefinitionKey processDefinitionKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get process definition XML Returns process definition as XML.

ParameterTypeDescription
processDefinitionKeyProcessDefinitionKey
consistencyConsistencyOptions<Object>
ctCancellationToken

Returns: Task<Object>

GetStartProcessFormAsync(ProcessDefinitionKey, ConsistencyOptions?, CancellationToken)

public Task<GetStartProcessFormResponse> GetStartProcessFormAsync(ProcessDefinitionKey processDefinitionKey, ConsistencyOptions<GetStartProcessFormResponse>? consistency = null, CancellationToken ct = default)

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.

ParameterTypeDescription
processDefinitionKeyProcessDefinitionKey
consistencyConsistencyOptions<GetStartProcessFormResponse>
ctCancellationToken

Returns: Task<GetStartProcessFormResponse>

SearchProcessDefinitionsAsync(SearchProcessDefinitionsRequest, ConsistencyOptions?, CancellationToken)

public Task<ProcessDefinitionSearchQueryResult> SearchProcessDefinitionsAsync(SearchProcessDefinitionsRequest body, ConsistencyOptions<ProcessDefinitionSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search process definitions Search for process definitions based on given criteria.

ParameterTypeDescription
bodySearchProcessDefinitionsRequest
consistencyConsistencyOptions<ProcessDefinitionSearchQueryResult>
ctCancellationToken

Returns: Task<ProcessDefinitionSearchQueryResult>