@camunda/camunda-api-zod-schemas 0.0.1

package/dist/8.8/document.js

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import { API_VERSION } from "../common.js";
+const documentMetadataSchema = z.object({
+  contentType: z.string(),
+  fileName: z.string(),
+  expiresAt: z.string(),
+  size: z.number(),
+  processDefinitionId: z.string(),
+  processInstanceKey: z.string(),
+  customProperties: z.record(z.string(), z.unknown())
+});
+const documentReferenceSchema = z.object({
+  "camunda.document.type": z.literal("camunda"),
+  storeId: z.string(),
+  documentId: z.string(),
+  contentHash: z.string(),
+  metadata: documentMetadataSchema
+});
+const documentCreationFailureDetailSchema = z.object({
+  fileName: z.string(),
+  detail: z.string()
+});
+const createDocumentsResponseBodySchema = z.object({
+  createdDocuments: z.array(documentReferenceSchema),
+  failedDocuments: z.array(documentCreationFailureDetailSchema)
+});
+const documentLinkRequestBodySchema = z.object({
+  timeToLive: z.number().optional().default(36e5)
+});
+const documentLinkSchema = z.object({
+  url: z.string(),
+  expiresAt: z.string()
+});
+const createDocument = {
+  method: "POST",
+  getUrl({ storeId, documentId }) {
+    const searchParams = new URLSearchParams();
+    if (storeId) {
+      searchParams.set("storeId", storeId);
+    }
+    if (documentId) {
+      searchParams.set("documentId", documentId);
+    }
+    const query = searchParams.toString();
+    return `/${API_VERSION}/documents${query ? `?${query}` : ""}`;
+  }
+};
+const createDocuments = {
+  method: "POST",
+  getUrl({ storeId } = {}) {
+    const searchParams = new URLSearchParams();
+    if (storeId) {
+      searchParams.set("storeId", storeId);
+    }
+    const query = searchParams.toString();
+    return `/${API_VERSION}/documents/batch${query ? `?${query}` : ""}`;
+  }
+};
+const getDocument = {
+  method: "GET",
+  getUrl({ documentId, storeId, contentHash }) {
+    const searchParams = new URLSearchParams();
+    if (storeId) {
+      searchParams.set("storeId", storeId);
+    }
+    if (contentHash) {
+      searchParams.set("contentHash", contentHash);
+    }
+    const query = searchParams.toString();
+    return `/${API_VERSION}/documents/${documentId}${query ? `?${query}` : ""}`;
+  }
+};
+const deleteDocument = {
+  method: "DELETE",
+  getUrl({ documentId, storeId }) {
+    const searchParams = new URLSearchParams();
+    if (storeId) {
+      searchParams.set("storeId", storeId);
+    }
+    const query = searchParams.toString();
+    return `/${API_VERSION}/documents/${documentId}${query ? `?${query}` : ""}`;
+  }
+};
+const createDocumentLink = {
+  method: "POST",
+  getUrl({ documentId, storeId, contentHash }) {
+    const searchParams = new URLSearchParams();
+    if (storeId) {
+      searchParams.set("storeId", storeId);
+    }
+    if (contentHash) {
+      searchParams.set("contentHash", contentHash);
+    }
+    const query = searchParams.toString();
+    return `/${API_VERSION}/documents/${documentId}/links${query ? `?${query}` : ""}`;
+  }
+};
+export {
+  createDocument,
+  createDocumentLink,
+  createDocuments,
+  createDocumentsResponseBodySchema,
+  deleteDocument,
+  documentCreationFailureDetailSchema,
+  documentLinkRequestBodySchema,
+  documentLinkSchema,
+  documentMetadataSchema,
+  documentReferenceSchema,
+  getDocument
+};

package/dist/8.8/element-instance.d.ts

@@ -0,0 +1,2 @@
+export * from '../element-instance'
+export {}

package/dist/8.8/element-instance.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { getEnumFilterSchema, getQueryRequestBodySchema, getQueryResponseBodySchema, API_VERSION } from "../common.js";
+const elementInstanceStateSchema = z.enum(["ACTIVE", "COMPLETED", "TERMINATED"]);
+const elementInstanceTypeSchema = z.enum([
+  "UNSPECIFIED",
+  "PROCESS",
+  "SUB_PROCESS",
+  "EVENT_SUB_PROCESS",
+  "AD_HOC_SUB_PROCESS",
+  "START_EVENT",
+  "INTERMEDIATE_CATCH_EVENT",
+  "INTERMEDIATE_THROW_EVENT",
+  "BOUNDARY_EVENT",
+  "END_EVENT",
+  "SERVICE_TASK",
+  "RECEIVE_TASK",
+  "USER_TASK",
+  "MANUAL_TASK",
+  "TASK",
+  "EXCLUSIVE_GATEWAY",
+  "INCLUSIVE_GATEWAY",
+  "PARALLEL_GATEWAY",
+  "EVENT_BASED_GATEWAY",
+  "SEQUENCE_FLOW",
+  "MULTI_INSTANCE_BODY",
+  "CALL_ACTIVITY",
+  "BUSINESS_RULE_TASK",
+  "SCRIPT_TASK",
+  "SEND_TASK",
+  "UNKNOWN"
+]);
+const elementInstanceSchema = z.object({
+  processDefinitionId: z.string(),
+  startDate: z.string(),
+  endDate: z.string().optional(),
+  elementId: z.string(),
+  elementName: z.string(),
+  type: elementInstanceTypeSchema,
+  state: elementInstanceStateSchema,
+  hasIncident: z.boolean(),
+  tenantId: z.string(),
+  elementInstanceKey: z.string(),
+  processInstanceKey: z.string(),
+  processDefinitionKey: z.string(),
+  incidentKey: z.string().optional()
+});
+const elementInstanceFilterSchema = z.object({
+  processDefinitionId: z.string(),
+  state: z.union([elementInstanceStateSchema, getEnumFilterSchema(elementInstanceStateSchema)]),
+  type: elementInstanceTypeSchema,
+  elementId: z.string(),
+  elementName: z.string(),
+  hasIncident: z.boolean(),
+  tenantId: z.string(),
+  elementInstanceKey: z.string(),
+  processInstanceKey: z.string(),
+  processDefinitionKey: z.string(),
+  incidentKey: z.string(),
+  scopeKey: z.string()
+}).partial();
+const queryElementInstancesRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: [
+    "elementInstanceKey",
+    "processInstanceKey",
+    "processDefinitionKey",
+    "processDefinitionId",
+    "startDate",
+    "endDate",
+    "elementId",
+    "elementName",
+    "type",
+    "state",
+    "incidentKey",
+    "tenantId"
+  ],
+  filter: elementInstanceFilterSchema
+});
+const queryElementInstancesResponseBodySchema = getQueryResponseBodySchema(elementInstanceSchema);
+const queryElementInstances = {
+  method: "POST",
+  getUrl() {
+    return `/${API_VERSION}/element-instances/search`;
+  }
+};
+const getElementInstance = {
+  method: "GET",
+  getUrl(params) {
+    const { elementInstanceKey } = params;
+    return `/${API_VERSION}/element-instances/${elementInstanceKey}`;
+  }
+};
+const getElementInstanceResponseBodySchema = elementInstanceSchema;
+const updateElementInstanceVariablesRequestBodySchema = z.object({
+  variables: z.record(z.string(), z.unknown()),
+  local: z.boolean().optional()
+});
+const updateElementInstanceVariables = {
+  method: "PUT",
+  getUrl(params) {
+    const { elementInstanceKey } = params;
+    return `/${API_VERSION}/element-instances/${elementInstanceKey}/variables`;
+  }
+};
+export {
+  elementInstanceFilterSchema,
+  elementInstanceSchema,
+  elementInstanceStateSchema,
+  elementInstanceTypeSchema,
+  getElementInstance,
+  getElementInstanceResponseBodySchema,
+  queryElementInstances,
+  queryElementInstancesRequestBodySchema,
+  queryElementInstancesResponseBodySchema,
+  updateElementInstanceVariables,
+  updateElementInstanceVariablesRequestBodySchema
+};

package/dist/8.8/group.d.ts

@@ -0,0 +1,2 @@
+export * from '../group'
+export {}

package/dist/8.8/group.js

@@ -0,0 +1,188 @@
+import { z } from "zod";
+import { getQueryRequestBodySchema, getQueryResponseBodySchema, API_VERSION } from "../common.js";
+import { mappingRuleSchema } from "./mapping-rule.js";
+import { userSchema } from "./user.js";
+import { groupSchema, roleSchema } from "../group-role.js";
+const createGroupRequestBodySchema = groupSchema;
+const createGroupResponseBodySchema = groupSchema;
+const createGroup = {
+  method: "POST",
+  getUrl() {
+    return `/${API_VERSION}/groups`;
+  }
+};
+const getGroup = {
+  method: "GET",
+  getUrl(params) {
+    const { groupId } = params;
+    return `/${API_VERSION}/groups/${groupId}`;
+  }
+};
+const getGroupResponseBodySchema = groupSchema;
+const updateGroupRequestBodySchema = groupSchema.pick({
+  name: true,
+  description: true
+});
+const updateGroupResponseBodySchema = groupSchema;
+const updateGroup = {
+  method: "PUT",
+  getUrl(params) {
+    const { groupId } = params;
+    return `/${API_VERSION}/groups/${groupId}`;
+  }
+};
+const deleteGroup = {
+  method: "DELETE",
+  getUrl(params) {
+    const { groupId } = params;
+    return `/${API_VERSION}/groups/${groupId}`;
+  }
+};
+const queryGroupsRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: ["name", "groupId"],
+  filter: groupSchema.pick({
+    groupId: true,
+    name: true
+  }).partial()
+});
+const queryGroupsResponseBodySchema = getQueryResponseBodySchema(groupSchema);
+const queryGroups = {
+  method: "POST",
+  getUrl() {
+    return `/${API_VERSION}/groups/search`;
+  }
+};
+const queryUsersByGroupRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: ["username"],
+  filter: z.never()
+});
+const queryUsersByGroupResponseBodySchema = getQueryResponseBodySchema(userSchema.pick({ username: true }));
+const queryUsersByGroup = {
+  method: "POST",
+  getUrl(params) {
+    const { groupId } = params;
+    return `/${API_VERSION}/groups/${groupId}/users/search`;
+  }
+};
+const queryClientsByGroupRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: ["clientId"],
+  filter: z.never()
+});
+const queryClientsByGroupResponseBodySchema = getQueryResponseBodySchema(
+  z.object({
+    clientId: z.string()
+  })
+);
+const queryClientsByGroup = {
+  method: "POST",
+  getUrl(params) {
+    const { groupId } = params;
+    return `/${API_VERSION}/groups/${groupId}/clients/search`;
+  }
+};
+const queryRolesByGroupRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: ["name", "roleId"],
+  filter: z.object({
+    roleId: z.string(),
+    name: z.string()
+  }).partial()
+});
+const queryRolesByGroupResponseBodySchema = getQueryResponseBodySchema(roleSchema.pick({ roleId: true, name: true }));
+const queryRolesByGroup = {
+  method: "POST",
+  getUrl(params) {
+    const { groupId } = params;
+    return `/${API_VERSION}/groups/${groupId}/roles/search`;
+  }
+};
+const queryMappingRulesByGroupRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: ["claimName", "claimValue", "name"],
+  filter: mappingRuleSchema.pick({
+    claimName: true,
+    claimValue: true,
+    name: true
+  }).partial()
+});
+const queryMappingRulesByGroupResponseBodySchema = getQueryResponseBodySchema(mappingRuleSchema);
+const queryMappingRulesByGroup = {
+  method: "POST",
+  getUrl(params) {
+    const { groupId } = params;
+    return `/${API_VERSION}/groups/${groupId}/mapping-rules/search`;
+  }
+};
+const assignUserToGroup = {
+  method: "PUT",
+  getUrl(params) {
+    const { groupId, username } = params;
+    return `/${API_VERSION}/groups/${groupId}/users/${username}`;
+  }
+};
+const unassignUserFromGroup = {
+  method: "DELETE",
+  getUrl(params) {
+    const { groupId, username } = params;
+    return `/${API_VERSION}/groups/${groupId}/users/${username}`;
+  }
+};
+const assignClientToGroup = {
+  method: "PUT",
+  getUrl(params) {
+    const { groupId, clientId } = params;
+    return `/${API_VERSION}/groups/${groupId}/clients/${clientId}`;
+  }
+};
+const unassignClientFromGroup = {
+  method: "DELETE",
+  getUrl(params) {
+    const { groupId, clientId } = params;
+    return `/${API_VERSION}/groups/${groupId}/clients/${clientId}`;
+  }
+};
+const assignMappingToGroup = {
+  method: "PUT",
+  getUrl(params) {
+    const { groupId, mappingId } = params;
+    return `/${API_VERSION}/groups/${groupId}/mapping-rules/${mappingId}`;
+  }
+};
+const unassignMappingFromGroup = {
+  method: "DELETE",
+  getUrl(params) {
+    const { groupId, mappingId } = params;
+    return `/${API_VERSION}/groups/${groupId}/mapping-rules/${mappingId}`;
+  }
+};
+export {
+  assignClientToGroup,
+  assignMappingToGroup,
+  assignUserToGroup,
+  createGroup,
+  createGroupRequestBodySchema,
+  createGroupResponseBodySchema,
+  deleteGroup,
+  getGroup,
+  getGroupResponseBodySchema,
+  groupSchema,
+  queryClientsByGroup,
+  queryClientsByGroupRequestBodySchema,
+  queryClientsByGroupResponseBodySchema,
+  queryGroups,
+  queryGroupsRequestBodySchema,
+  queryGroupsResponseBodySchema,
+  queryMappingRulesByGroup,
+  queryMappingRulesByGroupRequestBodySchema,
+  queryMappingRulesByGroupResponseBodySchema,
+  queryRolesByGroup,
+  queryRolesByGroupRequestBodySchema,
+  queryRolesByGroupResponseBodySchema,
+  queryUsersByGroup,
+  queryUsersByGroupRequestBodySchema,
+  queryUsersByGroupResponseBodySchema,
+  unassignClientFromGroup,
+  unassignMappingFromGroup,
+  unassignUserFromGroup,
+  updateGroup,
+  updateGroupRequestBodySchema,
+  updateGroupResponseBodySchema
+};

package/dist/8.8/incident.d.ts

@@ -0,0 +1,2 @@
+export * from '../incident'
+export {}

package/dist/8.8/incident.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { getQueryRequestBodySchema, getEnumFilterSchema, advancedDateTimeFilterSchema, getQueryResponseBodySchema, API_VERSION } from "../common.js";
+const incidentErrorTypeSchema = z.enum([
+  "UNSPECIFIED",
+  "UNKNOWN",
+  "IO_MAPPING_ERROR",
+  "JOB_NO_RETRIES",
+  "EXECUTION_LISTENER_NO_RETRIES",
+  "TASK_LISTENER_NO_RETRIES",
+  "CONDITION_ERROR",
+  "EXTRACT_VALUE_ERROR",
+  "CALLED_ELEMENT_ERROR",
+  "UNHANDLED_ERROR_EVENT",
+  "MESSAGE_SIZE_EXCEEDED",
+  "CALLED_DECISION_ERROR",
+  "DECISION_EVALUATION_ERROR",
+  "FORM_NOT_FOUND",
+  "RESOURCE_NOT_FOUND"
+]);
+const incidentStateSchema = z.enum(["ACTIVE", "MIGRATED", "RESOLVED", "PENDING"]);
+const incidentSchema = z.object({
+  processDefinitionId: z.string(),
+  errorType: incidentErrorTypeSchema,
+  errorMessage: z.string(),
+  elementId: z.string(),
+  creationTime: z.string(),
+  state: incidentStateSchema,
+  tenantId: z.string(),
+  incidentKey: z.string(),
+  processDefinitionKey: z.string(),
+  processInstanceKey: z.string(),
+  elementInstanceKey: z.string(),
+  jobKey: z.string()
+});
+const resolveIncident = {
+  method: "POST",
+  getUrl: ({ incidentKey }) => `/${API_VERSION}/incidents/${incidentKey}/resolution`
+};
+const getIncident = {
+  method: "GET",
+  getUrl: ({ incidentKey }) => `/${API_VERSION}/incidents/${incidentKey}`
+};
+const getIncidentResponseBodySchema = incidentSchema;
+const queryIncidentsRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: [
+    "incidentKey",
+    "processDefinitionKey",
+    "processDefinitionId",
+    "processInstanceKey",
+    "errorType",
+    "errorMessage",
+    "elementId",
+    "elementInstanceKey",
+    "creationTime",
+    "state",
+    "jobKey",
+    "tenantId"
+  ],
+  filter: z.object({
+    errorType: getEnumFilterSchema(incidentErrorTypeSchema),
+    creationTime: advancedDateTimeFilterSchema,
+    state: getEnumFilterSchema(incidentStateSchema),
+    ...incidentSchema.pick({
+      processDefinitionId: true,
+      errorMessage: true,
+      elementId: true,
+      tenantId: true,
+      incidentKey: true,
+      processDefinitionKey: true,
+      processInstanceKey: true,
+      elementInstanceKey: true,
+      jobKey: true
+    }).shape
+  }).partial()
+});
+const queryIncidentsResponseBodySchema = getQueryResponseBodySchema(incidentSchema);
+const queryIncidents = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/incidents/search`
+};
+export {
+  getIncident,
+  getIncidentResponseBodySchema,
+  incidentErrorTypeSchema,
+  incidentSchema,
+  incidentStateSchema,
+  queryIncidents,
+  queryIncidentsRequestBodySchema,
+  queryIncidentsResponseBodySchema,
+  resolveIncident
+};

package/dist/8.8/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../index'
+export {}