@camunda8/orchestration-cluster-api 1.0.0

package/dist/index.js

@@ -0,0 +1,730 @@
+import {
+  CamundaValidationError,
+  EventualConsistencyTimeoutError,
+  JobActionReceipt,
+  createCamundaClient,
+  createCamundaFpClient,
+  isLeft,
+  isRight
+} from "./chunk-W4C2PQ2F.js";
+import "./chunk-5JT7PDVS.js";
+
+// src/loose.ts
+function createCamundaClientLoose(...args) {
+  const strict = createCamundaClient(...args);
+  return strict;
+}
+
+// src/resultClient.ts
+var isOk = (r) => r.ok;
+var isErr = (r) => !r.ok;
+function isPromise(v) {
+  return v && typeof v.then === "function";
+}
+function createCamundaResultClient(options) {
+  const base = createCamundaClient(options);
+  const handler = {
+    get(_target, prop, _recv) {
+      if (prop === "inner") return base;
+      const value = base[prop];
+      if (typeof value !== "function") return value;
+      return (...args) => {
+        try {
+          const out = value.apply(base, args);
+          if (isPromise(out)) {
+            return out.then((v) => ({ ok: true, value: v })).catch((e) => ({ ok: false, error: e }));
+          }
+          return Promise.resolve({ ok: true, value: out });
+        } catch (e) {
+          return Promise.resolve({ ok: false, error: e });
+        }
+      };
+    }
+  };
+  return new Proxy({}, handler);
+}
+
+// src/gen/types.gen.ts
+function assertConstraint(value, label, c) {
+  if (c.pattern && !new RegExp(c.pattern).test(value)) throw new Error(`\x1B[31mInvalid pattern for ${label}: '${value}'.\x1B[0m Needs to match: ${JSON.stringify(c)}
+`);
+  if (typeof c.minLength === "number" && value.length < c.minLength) throw new Error(`Value too short for ${label}`);
+  if (typeof c.maxLength === "number" && value.length > c.maxLength) throw new Error(`Value too long for ${label}`);
+}
+var AuthorizationKey;
+((AuthorizationKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "AuthorizationKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  AuthorizationKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  AuthorizationKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "AuthorizationKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  AuthorizationKey2.isValid = isValid;
+})(AuthorizationKey || (AuthorizationKey = {}));
+var BatchOperationKey;
+((BatchOperationKey2) => {
+  function assumeExists(value) {
+    return value;
+  }
+  BatchOperationKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  BatchOperationKey2.getValue = getValue;
+  function isValid(value) {
+    return true;
+  }
+  BatchOperationKey2.isValid = isValid;
+})(BatchOperationKey || (BatchOperationKey = {}));
+var DecisionDefinitionId;
+((DecisionDefinitionId2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "DecisionDefinitionId", { pattern: "^[A-Za-z0-9_@.+-]+$", minLength: 1, maxLength: 256 });
+    return value;
+  }
+  DecisionDefinitionId2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  DecisionDefinitionId2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "DecisionDefinitionId", { pattern: "^[A-Za-z0-9_@.+-]+$", minLength: 1, maxLength: 256 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  DecisionDefinitionId2.isValid = isValid;
+})(DecisionDefinitionId || (DecisionDefinitionId = {}));
+var DecisionDefinitionKey;
+((DecisionDefinitionKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "DecisionDefinitionKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  DecisionDefinitionKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  DecisionDefinitionKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "DecisionDefinitionKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  DecisionDefinitionKey2.isValid = isValid;
+})(DecisionDefinitionKey || (DecisionDefinitionKey = {}));
+var DecisionEvaluationInstanceKey;
+((DecisionEvaluationInstanceKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "DecisionEvaluationInstanceKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  DecisionEvaluationInstanceKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  DecisionEvaluationInstanceKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "DecisionEvaluationInstanceKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  DecisionEvaluationInstanceKey2.isValid = isValid;
+})(DecisionEvaluationInstanceKey || (DecisionEvaluationInstanceKey = {}));
+var DecisionEvaluationKey;
+((DecisionEvaluationKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "DecisionEvaluationKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  DecisionEvaluationKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  DecisionEvaluationKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "DecisionEvaluationKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  DecisionEvaluationKey2.isValid = isValid;
+})(DecisionEvaluationKey || (DecisionEvaluationKey = {}));
+var DecisionInstanceKey;
+((DecisionInstanceKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "DecisionInstanceKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  DecisionInstanceKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  DecisionInstanceKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "DecisionInstanceKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  DecisionInstanceKey2.isValid = isValid;
+})(DecisionInstanceKey || (DecisionInstanceKey = {}));
+var DecisionRequirementsKey;
+((DecisionRequirementsKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "DecisionRequirementsKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  DecisionRequirementsKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  DecisionRequirementsKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "DecisionRequirementsKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  DecisionRequirementsKey2.isValid = isValid;
+})(DecisionRequirementsKey || (DecisionRequirementsKey = {}));
+var DeploymentKey;
+((DeploymentKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "DeploymentKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  DeploymentKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  DeploymentKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "DeploymentKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  DeploymentKey2.isValid = isValid;
+})(DeploymentKey || (DeploymentKey = {}));
+var DocumentId;
+((DocumentId2) => {
+  function assumeExists(value) {
+    return value;
+  }
+  DocumentId2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  DocumentId2.getValue = getValue;
+  function isValid(value) {
+    return true;
+  }
+  DocumentId2.isValid = isValid;
+})(DocumentId || (DocumentId = {}));
+var ElementId;
+((ElementId2) => {
+  function assumeExists(value) {
+    return value;
+  }
+  ElementId2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  ElementId2.getValue = getValue;
+  function isValid(value) {
+    return true;
+  }
+  ElementId2.isValid = isValid;
+})(ElementId || (ElementId = {}));
+var ElementInstanceKey;
+((ElementInstanceKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "ElementInstanceKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  ElementInstanceKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  ElementInstanceKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "ElementInstanceKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  ElementInstanceKey2.isValid = isValid;
+})(ElementInstanceKey || (ElementInstanceKey = {}));
+var EndCursor;
+((EndCursor2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "EndCursor", { pattern: "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=)?$", minLength: 2, maxLength: 300 });
+    return value;
+  }
+  EndCursor2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  EndCursor2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "EndCursor", { pattern: "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=)?$", minLength: 2, maxLength: 300 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  EndCursor2.isValid = isValid;
+})(EndCursor || (EndCursor = {}));
+var FormId;
+((FormId2) => {
+  function assumeExists(value) {
+    return value;
+  }
+  FormId2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  FormId2.getValue = getValue;
+  function isValid(value) {
+    return true;
+  }
+  FormId2.isValid = isValid;
+})(FormId || (FormId = {}));
+var FormKey;
+((FormKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "FormKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  FormKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  FormKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "FormKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  FormKey2.isValid = isValid;
+})(FormKey || (FormKey = {}));
+var IncidentKey;
+((IncidentKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "IncidentKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  IncidentKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  IncidentKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "IncidentKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  IncidentKey2.isValid = isValid;
+})(IncidentKey || (IncidentKey = {}));
+var JobKey;
+((JobKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "JobKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  JobKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  JobKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "JobKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  JobKey2.isValid = isValid;
+})(JobKey || (JobKey = {}));
+var MessageCorrelationKey;
+((MessageCorrelationKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "MessageCorrelationKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  MessageCorrelationKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  MessageCorrelationKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "MessageCorrelationKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  MessageCorrelationKey2.isValid = isValid;
+})(MessageCorrelationKey || (MessageCorrelationKey = {}));
+var MessageKey;
+((MessageKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "MessageKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  MessageKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  MessageKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "MessageKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  MessageKey2.isValid = isValid;
+})(MessageKey || (MessageKey = {}));
+var MessageSubscriptionKey;
+((MessageSubscriptionKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "MessageSubscriptionKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  MessageSubscriptionKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  MessageSubscriptionKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "MessageSubscriptionKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  MessageSubscriptionKey2.isValid = isValid;
+})(MessageSubscriptionKey || (MessageSubscriptionKey = {}));
+var ProcessDefinitionId;
+((ProcessDefinitionId2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "ProcessDefinitionId", { pattern: "^[a-zA-Z_][a-zA-Z0-9_\\-\\.]*$", minLength: 1 });
+    return value;
+  }
+  ProcessDefinitionId2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  ProcessDefinitionId2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "ProcessDefinitionId", { pattern: "^[a-zA-Z_][a-zA-Z0-9_\\-\\.]*$", minLength: 1 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  ProcessDefinitionId2.isValid = isValid;
+})(ProcessDefinitionId || (ProcessDefinitionId = {}));
+var ProcessDefinitionKey;
+((ProcessDefinitionKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "ProcessDefinitionKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  ProcessDefinitionKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  ProcessDefinitionKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "ProcessDefinitionKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  ProcessDefinitionKey2.isValid = isValid;
+})(ProcessDefinitionKey || (ProcessDefinitionKey = {}));
+var ProcessInstanceKey;
+((ProcessInstanceKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "ProcessInstanceKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  ProcessInstanceKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  ProcessInstanceKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "ProcessInstanceKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  ProcessInstanceKey2.isValid = isValid;
+})(ProcessInstanceKey || (ProcessInstanceKey = {}));
+var ScopeKey;
+((ScopeKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "ScopeKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  ScopeKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  ScopeKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "ScopeKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  ScopeKey2.isValid = isValid;
+})(ScopeKey || (ScopeKey = {}));
+var SignalKey;
+((SignalKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "SignalKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  SignalKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  SignalKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "SignalKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  SignalKey2.isValid = isValid;
+})(SignalKey || (SignalKey = {}));
+var StartCursor;
+((StartCursor2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "StartCursor", { pattern: "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=)?$", minLength: 2, maxLength: 300 });
+    return value;
+  }
+  StartCursor2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  StartCursor2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "StartCursor", { pattern: "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=)?$", minLength: 2, maxLength: 300 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  StartCursor2.isValid = isValid;
+})(StartCursor || (StartCursor = {}));
+var Tag;
+((Tag2) => {
+  function fromString(value) {
+    assertConstraint(value, "Tag", { pattern: "^[A-Za-z][A-Za-z0-9_\\-:.]{0,99}$", minLength: 1, maxLength: 100 });
+    return value;
+  }
+  Tag2.fromString = fromString;
+  function getValue(key) {
+    return key;
+  }
+  Tag2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "Tag", { pattern: "^[A-Za-z][A-Za-z0-9_\\-:.]{0,99}$", minLength: 1, maxLength: 100 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  Tag2.isValid = isValid;
+})(Tag || (Tag = {}));
+var TenantId;
+((TenantId2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "TenantId", { pattern: "^(<default>|[A-Za-z0-9_@.+-]+)$", minLength: 1, maxLength: 256 });
+    return value;
+  }
+  TenantId2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  TenantId2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "TenantId", { pattern: "^(<default>|[A-Za-z0-9_@.+-]+)$", minLength: 1, maxLength: 256 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  TenantId2.isValid = isValid;
+})(TenantId || (TenantId = {}));
+var Username;
+((Username2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "Username", { pattern: "^(<default>|[A-Za-z0-9_@.+-]+)$", minLength: 1, maxLength: 256 });
+    return value;
+  }
+  Username2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  Username2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "Username", { pattern: "^(<default>|[A-Za-z0-9_@.+-]+)$", minLength: 1, maxLength: 256 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  Username2.isValid = isValid;
+})(Username || (Username = {}));
+var UserTaskKey;
+((UserTaskKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "UserTaskKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  UserTaskKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  UserTaskKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "UserTaskKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  UserTaskKey2.isValid = isValid;
+})(UserTaskKey || (UserTaskKey = {}));
+var VariableKey;
+((VariableKey2) => {
+  function assumeExists(value) {
+    assertConstraint(value, "VariableKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+    return value;
+  }
+  VariableKey2.assumeExists = assumeExists;
+  function getValue(key) {
+    return key;
+  }
+  VariableKey2.getValue = getValue;
+  function isValid(value) {
+    try {
+      assertConstraint(value, "VariableKey", { pattern: "^-?[0-9]+$", minLength: 1, maxLength: 25 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  VariableKey2.isValid = isValid;
+})(VariableKey || (VariableKey = {}));
+
+// src/index.ts
+var index_default = createCamundaClient;
+export {
+  AuthorizationKey,
+  BatchOperationKey,
+  CamundaValidationError,
+  DecisionDefinitionId,
+  DecisionDefinitionKey,
+  DecisionEvaluationInstanceKey,
+  DecisionEvaluationKey,
+  DecisionInstanceKey,
+  DecisionRequirementsKey,
+  DeploymentKey,
+  DocumentId,
+  ElementId,
+  ElementInstanceKey,
+  EndCursor,
+  EventualConsistencyTimeoutError,
+  FormId,
+  FormKey,
+  IncidentKey,
+  JobActionReceipt as JobActionReceiptSymbol,
+  JobKey,
+  MessageCorrelationKey,
+  MessageKey,
+  MessageSubscriptionKey,
+  ProcessDefinitionId,
+  ProcessDefinitionKey,
+  ProcessInstanceKey,
+  ScopeKey,
+  SignalKey,
+  StartCursor,
+  Tag,
+  TenantId,
+  UserTaskKey,
+  Username,
+  VariableKey,
+  assertConstraint,
+  createCamundaClient,
+  createCamundaClientLoose,
+  createCamundaFpClient,
+  createCamundaResultClient,
+  index_default as default,
+  isErr,
+  isLeft,
+  isOk,
+  isRight
+};
+//# sourceMappingURL=index.js.map