// AUTO-GENERATED from camunda.json by @bpmn-io/moddle-types-generator — do not edit.

import type { ModdleElement } from 'moddle';
import type { BpmnErrorEventDefinition, BpmnResourceAssignmentExpression, BpmnTimerEventDefinition } from 'bpmn-moddle/types';

export interface CamundaDefinitions {
  diagramRelationId?: string;
}

export interface CamundaInOutBinding {
  source?: string;
  sourceExpression?: string;
  target?: string;
  businessKey?: string;
  local?: boolean;
  variables?: string;
}

export interface CamundaIn extends CamundaInOutBinding {
}

export interface CamundaOut extends CamundaInOutBinding {
}

export interface CamundaAsyncCapable {
  async?: boolean;
  asyncBefore?: boolean;
  asyncAfter?: boolean;
  exclusive?: boolean;
}

export interface CamundaJobPriorized {
  jobPriority?: string;
}

export interface CamundaSignalEventDefinitionExtension {
  async?: boolean;
}

export interface CamundaErrorEventDefinitionExtension {
  errorCodeVariable?: string;
  errorMessageVariable?: string;
}

export interface CamundaErrorEventDefinition extends BpmnErrorEventDefinition {
  expression?: string;
}

export interface CamundaError {
  'camunda:errorMessage'?: string;
}

export interface CamundaPotentialStarter {
  resourceAssignmentExpression?: ModdleElement<BpmnResourceAssignmentExpression>;
}

export interface CamundaFormSupported {
  formHandlerClass?: string;
  formKey?: string;
  formRef?: string;
  formRefBinding?: string;
  formRefVersion?: string;
}

export interface CamundaTemplateSupported {
  modelerTemplate?: string;
  modelerTemplateVersion?: number;
}

export interface CamundaInitiator {
  initiator?: string;
}

export interface CamundaScriptTask {
  resultVariable?: string;
  resource?: string;
}

export interface CamundaProcess {
  candidateStarterGroups?: string;
  candidateStarterUsers?: string;
  versionTag?: string;
  historyTimeToLive?: string;
  isStartableInTasklist?: boolean;
}

export interface CamundaEscalationEventDefinitionExtension {
  escalationCodeVariable?: string;
}

export interface CamundaFormalExpression {
  resource?: string;
}

export interface CamundaAssignable {
  assignee?: string;
  candidateUsers?: string;
  candidateGroups?: string;
  dueDate?: string;
  followUpDate?: string;
  priority?: string;
}

export interface CamundaCallActivity {
  calledElementBinding?: string;
  calledElementVersion?: string;
  calledElementVersionTag?: string;
  calledElementTenantId?: string;
  caseRef?: string;
  caseBinding?: string;
  caseVersion?: string;
  caseTenantId?: string;
  variableMappingClass?: string;
  variableMappingDelegateExpression?: string;
}

export interface CamundaServiceTaskLike {
  expression?: string;
  class?: string;
  delegateExpression?: string;
  resultVariable?: string;
}

export interface CamundaDmnCapable {
  decisionRef?: string;
  decisionRefBinding?: string;
  decisionRefVersion?: string;
  mapDecisionResult?: string;
  decisionRefTenantId?: string;
}

export interface CamundaExternalCapable {
  type?: string;
  topic?: string;
}

export interface CamundaTaskPriorized {
  taskPriority?: string;
}

export interface CamundaProperties {
  values?: ModdleElement<CamundaProperty>[];
}

export interface CamundaProperty {
  id?: string;
  name?: string;
  value?: string;
}

export interface CamundaConnector {
  inputOutput?: ModdleElement<CamundaInputOutput>;
  connectorId?: string;
}

export interface CamundaInputOutput {
  inputOutput?: ModdleElement<CamundaInputOutput>;
  connectorId?: string;
  inputParameters?: ModdleElement<CamundaInputParameter>[];
  outputParameters?: ModdleElement<CamundaOutputParameter>[];
}

export interface CamundaInputOutputParameter {
  name?: string;
  value?: string;
  definition?: ModdleElement<CamundaInputOutputParameterDefinition>;
}

export interface CamundaInputOutputParameterDefinition {
}

export interface CamundaList extends CamundaInputOutputParameterDefinition {
  items?: ModdleElement<CamundaInputOutputParameterDefinition>[];
}

export interface CamundaMap extends CamundaInputOutputParameterDefinition {
  entries?: ModdleElement<CamundaEntry>[];
}

export interface CamundaEntry {
  key?: string;
  value?: string;
  definition?: ModdleElement<CamundaInputOutputParameterDefinition>;
}

export interface CamundaValue extends CamundaInputOutputParameterDefinition {
  id?: string;
  name?: string;
  value?: string;
}

export interface CamundaScript extends CamundaInputOutputParameterDefinition {
  scriptFormat?: string;
  resource?: string;
  value?: string;
}

export interface CamundaField {
  name?: string;
  expression?: string;
  stringValue?: string;
  string?: string;
}

export interface CamundaInputParameter extends CamundaInputOutputParameter {
}

export interface CamundaOutputParameter extends CamundaInputOutputParameter {
}

export interface CamundaCollectable extends CamundaAsyncCapable {
  collection?: string;
  elementVariable?: string;
}

export interface CamundaFailedJobRetryTimeCycle {
  body?: string;
}

export interface CamundaExecutionListener {
  expression?: string;
  class?: string;
  delegateExpression?: string;
  event?: string;
  script?: ModdleElement<CamundaScript>;
  fields?: ModdleElement<CamundaField>[];
}

export interface CamundaTaskListener {
  expression?: string;
  class?: string;
  delegateExpression?: string;
  event?: string;
  script?: ModdleElement<CamundaScript>;
  fields?: ModdleElement<CamundaField>[];
  id?: string;
  eventDefinitions?: ModdleElement<BpmnTimerEventDefinition>[];
}

export interface CamundaFormProperty {
  id?: string;
  name?: string;
  type?: string;
  required?: string;
  readable?: string;
  writable?: string;
  variable?: string;
  expression?: string;
  datePattern?: string;
  default?: string;
  values?: ModdleElement<CamundaValue>[];
}

export interface CamundaFormData {
  fields?: ModdleElement<CamundaFormField>[];
  businessKey?: string;
}

export interface CamundaFormField {
  id?: string;
  label?: string;
  type?: string;
  datePattern?: string;
  defaultValue?: string;
  properties?: ModdleElement<CamundaProperties>;
  validation?: ModdleElement<CamundaValidation>;
  values?: ModdleElement<CamundaValue>[];
}

export interface CamundaValidation {
  constraints?: ModdleElement<CamundaConstraint>[];
}

export interface CamundaConstraint {
  name?: string;
  config?: string;
}

export interface CamundaConditionalEventDefinitionExtension {
  variableName?: string;
  variableEvents?: string;
}

export interface CamundaModdleTypeMap {
  'camunda:In': ModdleElement<CamundaIn> & { $type: 'camunda:In' };
  'camunda:Out': ModdleElement<CamundaOut> & { $type: 'camunda:Out' };
  'camunda:ErrorEventDefinition': ModdleElement<CamundaErrorEventDefinition> & { $type: 'camunda:ErrorEventDefinition' };
  'camunda:PotentialStarter': ModdleElement<CamundaPotentialStarter> & { $type: 'camunda:PotentialStarter' };
  'camunda:Properties': ModdleElement<CamundaProperties> & { $type: 'camunda:Properties' };
  'camunda:Property': ModdleElement<CamundaProperty> & { $type: 'camunda:Property' };
  'camunda:Connector': ModdleElement<CamundaConnector> & { $type: 'camunda:Connector' };
  'camunda:InputOutput': ModdleElement<CamundaInputOutput> & { $type: 'camunda:InputOutput' };
  'camunda:InputOutputParameter': ModdleElement<CamundaInputOutputParameter> & { $type: 'camunda:InputOutputParameter' };
  'camunda:List': ModdleElement<CamundaList> & { $type: 'camunda:List' };
  'camunda:Map': ModdleElement<CamundaMap> & { $type: 'camunda:Map' };
  'camunda:Entry': ModdleElement<CamundaEntry> & { $type: 'camunda:Entry' };
  'camunda:Value': ModdleElement<CamundaValue> & { $type: 'camunda:Value' };
  'camunda:Script': ModdleElement<CamundaScript> & { $type: 'camunda:Script' };
  'camunda:Field': ModdleElement<CamundaField> & { $type: 'camunda:Field' };
  'camunda:InputParameter': ModdleElement<CamundaInputParameter> & { $type: 'camunda:InputParameter' };
  'camunda:OutputParameter': ModdleElement<CamundaOutputParameter> & { $type: 'camunda:OutputParameter' };
  'camunda:FailedJobRetryTimeCycle': ModdleElement<CamundaFailedJobRetryTimeCycle> & { $type: 'camunda:FailedJobRetryTimeCycle' };
  'camunda:ExecutionListener': ModdleElement<CamundaExecutionListener> & { $type: 'camunda:ExecutionListener' };
  'camunda:TaskListener': ModdleElement<CamundaTaskListener> & { $type: 'camunda:TaskListener' };
  'camunda:FormProperty': ModdleElement<CamundaFormProperty> & { $type: 'camunda:FormProperty' };
  'camunda:FormData': ModdleElement<CamundaFormData> & { $type: 'camunda:FormData' };
  'camunda:FormField': ModdleElement<CamundaFormField> & { $type: 'camunda:FormField' };
  'camunda:Validation': ModdleElement<CamundaValidation> & { $type: 'camunda:Validation' };
  'camunda:Constraint': ModdleElement<CamundaConstraint> & { $type: 'camunda:Constraint' };
}