@camunda/camunda-api-zod-schemas 0.0.1

package/README.md

@@ -0,0 +1,28 @@
+# @camunda/camunda-api-zod-schemas
+
+This is a community-driven open-source project that provides [Zod](https://zod.dev/) schemas and TypeScript type definitions for the Camunda 8 REST API.
+
+It aims to help developers build robust and type-safe applications when interacting with Camunda 8.
+
+The official Camunda 8 REST API documentation can be found here: [https://docs.camunda.io/docs/next/apis-tools/camunda-api-rest/camunda-api-rest-overview/](https://docs.camunda.io/docs/next/apis-tools/camunda-api-rest/camunda-api-rest-overview/)
+
+## Installation
+
+You can install the package using your favorite package manager:
+
+```bash
+# pnpm
+pnpm add @camunda/camunda-api-zod-schemas
+
+# npm
+npm install @camunda/camunda-api-zod-schemas
+
+# yarn
+yarn add @camunda/camunda-api-zod-schemas
+```
+
+## Usage
+
+The library exports modules that correspond to the different parts of the Camunda API. You can import the schemas and types you need from the main package or specific version sub-modules like `@camunda/camunda-api-zod-schemas/8.8`.
+
+Refer to the exported members from `lib/8.8/index.ts` and other files in the `lib` directory for available schemas and types.

package/dist/8.8/ad-hoc-sub-process.d.ts

@@ -0,0 +1,2 @@
+export * from '../ad-hoc-sub-process'
+export {}

package/dist/8.8/ad-hoc-sub-process.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { getCollectionResponseBodySchema, API_VERSION } from "../common.js";
+const activityTypeSchema = z.enum([
+  "UNSPECIFIED",
+  "PROCESS",
+  "SUB_PROCESS",
+  "EVENT_SUB_PROCESS",
+  "INTERMEDIATE_CATCH_EVENT",
+  "INTERMEDIATE_THROW_EVENT",
+  "BOUNDARY_EVENT",
+  "SERVICE_TASK",
+  "RECEIVE_TASK",
+  "USER_TASK",
+  "MANUAL_TASK",
+  "TASK",
+  "MULTI_INSTANCE_BODY",
+  "CALL_ACTIVITY",
+  "BUSINESS_RULE_TASK",
+  "SCRIPT_TASK",
+  "SEND_TASK",
+  "UNKNOWN"
+]);
+const adHocSubProcessActivityFilterSchema = z.object({
+  processDefinitionKey: z.string(),
+  adHocSubProcessId: z.string()
+});
+const queryActivatableActivitiesRequestBodySchema = z.object({
+  filter: adHocSubProcessActivityFilterSchema
+});
+const activatableActivitySchema = z.object({
+  processDefinitionKey: z.string(),
+  processDefinitionId: z.string(),
+  adHocSubProcessId: z.string(),
+  elementId: z.string(),
+  elementName: z.string(),
+  type: activityTypeSchema,
+  documentation: z.string(),
+  tenantId: z.string()
+});
+const queryActivatableActivitiesResponseBodySchema = getCollectionResponseBodySchema(activatableActivitySchema);
+const activateActivityWithinAdHocSubProcessRequestBodySchema = z.object({
+  elementId: z.string()
+});
+const activateActivityWithinAdHocSubProcessResponseBodySchema = z.object({
+  elements: z.array(
+    z.object({
+      elementId: z.string()
+    })
+  )
+});
+const queryActivatableActivities = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/element-instances/ad-hoc-activities/search`
+};
+const activateAdHocSubProcessActivities = {
+  method: "POST",
+  getUrl: ({ adHocSubProcessInstanceKey }) => `/${API_VERSION}/element-instances/ad-hoc-activities/${adHocSubProcessInstanceKey}/activation`
+};
+export {
+  activateActivityWithinAdHocSubProcessRequestBodySchema,
+  activateActivityWithinAdHocSubProcessResponseBodySchema,
+  activateAdHocSubProcessActivities,
+  activityTypeSchema,
+  queryActivatableActivities,
+  queryActivatableActivitiesRequestBodySchema,
+  queryActivatableActivitiesResponseBodySchema
+};

package/dist/8.8/authentication.d.ts

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

package/dist/8.8/authentication.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { API_VERSION } from "../common.js";
+const currentUserSchema = z.object({
+  username: z.string(),
+  displayName: z.string(),
+  email: z.string(),
+  authorizedComponents: z.array(z.string()),
+  tenants: z.array(
+    z.object({
+      key: z.number(),
+      tenantId: z.string(),
+      name: z.string(),
+      description: z.string().optional()
+    })
+  ),
+  groups: z.array(z.string()),
+  roles: z.array(z.string()),
+  salesPlanType: z.string().nullable(),
+  c8Links: z.array(
+    z.object({
+      name: z.string(),
+      link: z.string()
+    })
+  ),
+  canLogout: z.boolean(),
+  apiUser: z.boolean().optional()
+});
+const getCurrentUser = {
+  method: "GET",
+  getUrl: () => `/${API_VERSION}/authentication/me`
+};
+export {
+  currentUserSchema,
+  getCurrentUser
+};

package/dist/8.8/authorization.d.ts

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

package/dist/8.8/authorization.js

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { getQueryRequestBodySchema, getQueryResponseBodySchema, API_VERSION } from "../common.js";
+const permissionTypeSchema = z.enum([
+  "ACCESS",
+  "CREATE",
+  "CREATE_BATCH_OPERATION_CANCEL_PROCESS_INSTANCE",
+  "CREATE_BATCH_OPERATION_DELETE_PROCESS_INSTANCE",
+  "CREATE_BATCH_OPERATION_MIGRATE_PROCESS_INSTANCE",
+  "CREATE_BATCH_OPERATION_MODIFY_PROCESS_INSTANCE",
+  "CREATE_BATCH_OPERATION_RESOLVE_INCIDENT",
+  "CREATE_BATCH_OPERATION_DELETE_DECISION_INSTANCE",
+  "CREATE_BATCH_OPERATION_DELETE_DECISION_DEFINITION",
+  "CREATE_BATCH_OPERATION_DELETE_PROCESS_DEFINITION",
+  "CREATE_PROCESS_INSTANCE",
+  "CREATE_DECISION_INSTANCE",
+  "READ",
+  "READ_PROCESS_INSTANCE",
+  "READ_USER_TASK",
+  "READ_DECISION_INSTANCE",
+  "READ_PROCESS_DEFINITION",
+  "READ_DECISION_DEFINITION",
+  "UPDATE",
+  "UPDATE_PROCESS_INSTANCE",
+  "UPDATE_USER_TASK",
+  "DELETE",
+  "DELETE_PROCESS",
+  "DELETE_DRD",
+  "DELETE_FORM",
+  "DELETE_RESOURCE",
+  "DELETE_PROCESS_INSTANCE",
+  "DELETE_DECISION_INSTANCE"
+]);
+const resourceTypeSchema = z.enum([
+  "AUTHORIZATION",
+  "MAPPING_RULE",
+  "MESSAGE",
+  "BATCH",
+  "BATCH_OPERATION",
+  "APPLICATION",
+  "SYSTEM",
+  "TENANT",
+  "RESOURCE",
+  "PROCESS_DEFINITION",
+  "DECISION_REQUIREMENTS_DEFINITION",
+  "DECISION_DEFINITION",
+  "GROUP",
+  "USER",
+  "ROLE"
+]);
+const ownerTypeSchema = z.enum(["USER", "CLIENT", "ROLE", "GROUP", "MAPPING", "UNSPECIFIED"]);
+const authorizationSchema = z.object({
+  ownerId: z.string(),
+  ownerType: ownerTypeSchema,
+  resourceType: resourceTypeSchema,
+  resourceId: z.string(),
+  permissionTypes: z.array(permissionTypeSchema),
+  authorizationKey: z.string()
+});
+const createAuthorizationRequestBodySchema = authorizationSchema.pick({
+  ownerId: true,
+  ownerType: true,
+  resourceType: true,
+  resourceId: true,
+  permissionTypes: true
+});
+const updateAuthorizationRequestBodySchema = createAuthorizationRequestBodySchema.partial();
+const queryAuthorizationsRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: ["ownerId", "ownerType", "resourceId", "resourceType"],
+  filter: z.object({
+    resourceId: z.array(z.string()),
+    ...authorizationSchema.pick({
+      ownerId: true,
+      ownerType: true,
+      resourceType: true
+    }).shape
+  }).partial()
+});
+const queryAuthorizationsResponseBodySchema = getQueryResponseBodySchema(authorizationSchema);
+const createAuthorization = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/authorizations`
+};
+const updateAuthorization = {
+  method: "PUT",
+  getUrl: ({ authorizationKey }) => `/${API_VERSION}/authorizations/${authorizationKey}`
+};
+const getAuthorization = {
+  method: "GET",
+  getUrl: ({ authorizationKey }) => `/${API_VERSION}/authorizations/${authorizationKey}`
+};
+const deleteAuthorization = {
+  method: "DELETE",
+  getUrl: ({ authorizationKey }) => `/${API_VERSION}/authorizations/${authorizationKey}`
+};
+const queryAuthorizations = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/authorizations/search`
+};
+export {
+  authorizationSchema,
+  createAuthorization,
+  createAuthorizationRequestBodySchema,
+  deleteAuthorization,
+  getAuthorization,
+  ownerTypeSchema,
+  permissionTypeSchema,
+  queryAuthorizations,
+  queryAuthorizationsRequestBodySchema,
+  queryAuthorizationsResponseBodySchema,
+  resourceTypeSchema,
+  updateAuthorization,
+  updateAuthorizationRequestBodySchema
+};

package/dist/8.8/batch-operation.d.ts

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

package/dist/8.8/batch-operation.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { getQueryRequestBodySchema, getQueryResponseBodySchema, API_VERSION } from "../common.js";
+const batchOperationTypeSchema = z.enum([
+  "CANCEL_PROCESS_INSTANCE",
+  "RESOLVE_INCIDENT",
+  "MIGRATE_PROCESS_INSTANCE",
+  "MODIFY_PROCESS_INSTANCE"
+]);
+const batchOperationStateSchema = z.enum([
+  "CREATED",
+  "ACTIVE",
+  "SUSPENDED",
+  "COMPLETED",
+  "COMPLETED_WITH_ERRORS",
+  "CANCELED",
+  "INCOMPLETED"
+]);
+const batchOperationItemStateSchema = z.enum(["ACTIVE", "COMPLETED", "CANCELED", "FAILED"]);
+const batchOperationSchema = z.object({
+  batchOperationKey: z.string(),
+  state: batchOperationStateSchema,
+  batchOperationType: batchOperationTypeSchema,
+  startDate: z.string(),
+  endDate: z.string().optional(),
+  operationsTotalCount: z.number().int(),
+  operationsFailedCount: z.number().int(),
+  operationsCompletedCount: z.number().int()
+});
+const batchOperationItemSchema = z.object({
+  batchOperationKey: z.string(),
+  itemKey: z.string(),
+  processInstanceKey: z.string(),
+  state: batchOperationItemStateSchema,
+  processedDate: z.string().optional(),
+  errorMessage: z.string().optional()
+});
+const queryBatchOperationsRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: ["batchOperationKey", "operationType", "state", "startDate", "endDate"],
+  filter: z.object({
+    batchOperationKey: z.string(),
+    operationType: batchOperationTypeSchema,
+    state: batchOperationStateSchema
+  }).partial()
+});
+const queryBatchOperationsResponseBodySchema = getQueryResponseBodySchema(batchOperationSchema);
+const queryBatchOperationItemsRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: ["batchOperationKey", "itemKey", "processInstanceKey", "state"],
+  filter: z.object({
+    batchOperationKey: z.string(),
+    itemKey: z.string(),
+    processInstanceKey: z.string(),
+    state: batchOperationItemStateSchema
+  }).partial()
+});
+const queryBatchOperationItemsResponseBodySchema = getQueryResponseBodySchema(batchOperationItemSchema);
+const getBatchOperation = {
+  method: "GET",
+  getUrl: ({ batchOperationKey }) => `/${API_VERSION}/batch-operations/${batchOperationKey}`
+};
+const queryBatchOperations = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/batch-operations/search`
+};
+const cancelBatchOperation = {
+  method: "PUT",
+  getUrl: ({ batchOperationKey }) => `/${API_VERSION}/batch-operations/${batchOperationKey}/cancellation`
+};
+const suspendBatchOperation = {
+  method: "PUT",
+  getUrl: ({ batchOperationKey }) => `/${API_VERSION}/batch-operations/${batchOperationKey}/suspension`
+};
+const resumeBatchOperation = {
+  method: "PUT",
+  getUrl: ({ batchOperationKey }) => `/${API_VERSION}/batch-operations/${batchOperationKey}/resumption`
+};
+const queryBatchOperationItems = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/batch-operation-items/search`
+};
+export {
+  batchOperationItemSchema,
+  batchOperationItemStateSchema,
+  batchOperationSchema,
+  batchOperationStateSchema,
+  batchOperationTypeSchema,
+  cancelBatchOperation,
+  getBatchOperation,
+  queryBatchOperationItems,
+  queryBatchOperationItemsRequestBodySchema,
+  queryBatchOperationItemsResponseBodySchema,
+  queryBatchOperations,
+  queryBatchOperationsRequestBodySchema,
+  queryBatchOperationsResponseBodySchema,
+  resumeBatchOperation,
+  suspendBatchOperation
+};

package/dist/8.8/clock.d.ts

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

package/dist/8.8/clock.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { API_VERSION } from "../common.js";
+const pinClockRequestBodySchema = z.object({
+  timestamp: z.number().int()
+});
+const pinClock = {
+  method: "PUT",
+  getUrl: () => `/${API_VERSION}/clock`
+};
+const resetClock = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/clock/reset`
+};
+export {
+  pinClock,
+  pinClockRequestBodySchema,
+  resetClock
+};

package/dist/8.8/cluster.d.ts

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

package/dist/8.8/cluster.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { API_VERSION } from "../common.js";
+const partitionRoleSchema = z.enum(["leader", "follower", "inactive"]);
+const partitionHealthSchema = z.enum(["healthy", "unhealthy", "dead"]);
+const partitionSchema = z.object({
+  partitionId: z.number().int(),
+  role: partitionRoleSchema,
+  health: partitionHealthSchema
+});
+const brokerInfoSchema = z.object({
+  nodeId: z.number().int(),
+  host: z.string(),
+  port: z.number().int(),
+  partitions: z.array(partitionSchema),
+  version: z.string()
+});
+const getTopologyResponseBodySchema = z.object({
+  brokers: z.array(brokerInfoSchema).nullable(),
+  clusterSize: z.number().int().nullable(),
+  partitionsCount: z.number().int().nullable(),
+  replicationFactor: z.number().int().nullable(),
+  gatewayVersion: z.string().nullable(),
+  lastCompletedChangeId: z.string().nullable()
+});
+const getTopology = {
+  method: "GET",
+  getUrl: () => `/${API_VERSION}/topology`
+};
+export {
+  brokerInfoSchema,
+  getTopology,
+  getTopologyResponseBodySchema,
+  partitionHealthSchema,
+  partitionRoleSchema,
+  partitionSchema
+};

package/dist/8.8/decision-definition.d.ts

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

package/dist/8.8/decision-definition.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { getQueryRequestBodySchema, getQueryResponseBodySchema, API_VERSION } from "../common.js";
+const decisionDefinitionSchema = z.object({
+  decisionDefinitionId: z.string(),
+  name: z.string(),
+  version: z.number(),
+  decisionRequirementsId: z.string(),
+  tenantId: z.string(),
+  decisionDefinitionKey: z.string(),
+  decisionRequirementsKey: z.string()
+});
+const queryDecisionDefinitionsRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: [
+    "decisionDefinitionKey",
+    "decisionDefinitionId",
+    "name",
+    "version",
+    "decisionRequirementsId",
+    "decisionRequirementsKey",
+    "tenantId"
+  ],
+  filter: decisionDefinitionSchema.partial()
+});
+const queryDecisionDefinitionsResponseBodySchema = getQueryResponseBodySchema(decisionDefinitionSchema);
+const getDecisionDefinitionXmlResponseBodySchema = z.string();
+const evaluatedDecisionInputItemSchema = z.object({
+  inputId: z.string(),
+  inputName: z.string(),
+  inputValue: z.string()
+});
+const evaluatedDecisionOutputItemSchema = z.object({
+  outputId: z.string(),
+  outputName: z.string(),
+  outputValue: z.string()
+});
+const matchedDecisionRuleItemSchema = z.object({
+  ruleId: z.string(),
+  ruleIndex: z.number().int(),
+  evaluatedOutputs: z.array(evaluatedDecisionOutputItemSchema)
+});
+const evaluatedDecisionResultSchema = z.object({
+  decisionDefinitionId: z.string(),
+  decisionDefinitionName: z.string(),
+  decisionDefinitionVersion: z.number().int(),
+  decisionDefinitionType: z.string(),
+  output: z.string(),
+  tenantId: z.string(),
+  matchedRules: z.array(matchedDecisionRuleItemSchema),
+  evaluatedInputs: z.array(evaluatedDecisionInputItemSchema),
+  decisionDefinitionKey: z.string()
+});
+const evaluateDecisionRequestBodySchema = z.object({
+  decisionDefinitionId: z.string().optional(),
+  variables: z.record(z.string(), z.unknown()).optional(),
+  tenantId: z.string().optional(),
+  decisionDefinitionKey: z.string().optional()
+});
+const evaluateDecisionResponseBodySchema = z.object({
+  decisionDefinitionId: z.string(),
+  decisionDefinitionName: z.string(),
+  decisionDefinitionVersion: z.number().int(),
+  decisionRequirementsId: z.string(),
+  output: z.string(),
+  failedDecisionDefinitionId: z.string().optional(),
+  failureMessage: z.string().optional(),
+  tenantId: z.string(),
+  decisionDefinitionKey: z.string(),
+  decisionRequirementsKey: z.string(),
+  decisionInstanceKey: z.string(),
+  evaluatedDecisions: z.array(evaluatedDecisionResultSchema)
+});
+const queryDecisionDefinitions = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/decision-definitions/search`
+};
+const getDecisionDefinition = {
+  method: "GET",
+  getUrl: ({ decisionDefinitionKey }) => `/${API_VERSION}/decision-definitions/${decisionDefinitionKey}`
+};
+const getDecisionDefinitionXml = {
+  method: "GET",
+  getUrl: ({ decisionDefinitionKey }) => `/${API_VERSION}/decision-definitions/${decisionDefinitionKey}/xml`
+};
+const evaluateDecision = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/decision-definitions/evaluation`
+};
+export {
+  decisionDefinitionSchema,
+  evaluateDecision,
+  evaluateDecisionRequestBodySchema,
+  evaluateDecisionResponseBodySchema,
+  evaluatedDecisionInputItemSchema,
+  evaluatedDecisionOutputItemSchema,
+  evaluatedDecisionResultSchema,
+  getDecisionDefinition,
+  getDecisionDefinitionXml,
+  getDecisionDefinitionXmlResponseBodySchema,
+  matchedDecisionRuleItemSchema,
+  queryDecisionDefinitions,
+  queryDecisionDefinitionsRequestBodySchema,
+  queryDecisionDefinitionsResponseBodySchema
+};

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

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

package/dist/8.8/decision-instance.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { getQueryRequestBodySchema, basicStringFilterSchema, advancedDateTimeFilterSchema, getQueryResponseBodySchema, API_VERSION } from "../common.js";
+import { matchedDecisionRuleItemSchema, evaluatedDecisionInputItemSchema } from "./decision-definition.js";
+const decisionDefinitionTypeSchema = z.enum(["DECISION_TABLE", "LITERAL_EXPRESSION", "UNSPECIFIED", "UNKNOWN"]);
+const decisionInstanceStateSchema = z.enum(["EVALUATED", "FAILED", "UNSPECIFIED", "UNKNOWN"]);
+const decisionInstanceSchema = z.object({
+  decisionInstanceId: z.string(),
+  state: decisionInstanceStateSchema,
+  evaluationDate: z.string(),
+  evaluationFailure: z.string(),
+  decisionDefinitionId: z.string(),
+  decisionDefinitionName: z.string(),
+  decisionDefinitionVersion: z.number(),
+  decisionDefinitionType: decisionDefinitionTypeSchema,
+  result: z.string(),
+  tenantId: z.string(),
+  decisionInstanceKey: z.string(),
+  processDefinitionKey: z.string(),
+  processInstanceKey: z.string(),
+  decisionDefinitionKey: z.string(),
+  elementInstanceKey: z.string()
+});
+const queryDecisionInstancesRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: [
+    "decisionInstanceKey",
+    "decisionInstanceId",
+    "state",
+    "evaluationDate",
+    "evaluationFailure",
+    "processDefinitionKey",
+    "processInstanceKey",
+    "processInstanceId",
+    "decisionDefinitionKey",
+    "decisionDefinitionId",
+    "decisionDefinitionName",
+    "decisionDefinitionVersion",
+    "decisionDefinitionType",
+    "tenantId",
+    "elementInstanceKey"
+  ],
+  filter: z.object({
+    evaluationDate: advancedDateTimeFilterSchema,
+    decisionDefinitionKey: basicStringFilterSchema,
+    ...decisionInstanceSchema.pick({
+      decisionInstanceId: true,
+      state: true,
+      evaluationFailure: true,
+      decisionDefinitionId: true,
+      decisionDefinitionName: true,
+      decisionDefinitionVersion: true,
+      decisionDefinitionType: true,
+      tenantId: true,
+      decisionInstanceKey: true,
+      processDefinitionKey: true,
+      processInstanceKey: true,
+      elementInstanceKey: true
+    }).shape
+  }).partial()
+});
+const queryDecisionInstancesResponseBodySchema = getQueryResponseBodySchema(decisionInstanceSchema);
+const getDecisionInstanceResponseBodySchema = z.object({
+  evaluatedInputs: z.array(evaluatedDecisionInputItemSchema).optional(),
+  matchedRules: z.array(matchedDecisionRuleItemSchema).optional(),
+  ...decisionInstanceSchema.shape
+});
+const queryDecisionInstances = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/decision-instances/search`
+};
+const getDecisionInstance = {
+  method: "GET",
+  getUrl: ({ decisionInstanceId }) => `/${API_VERSION}/decision-instances/${decisionInstanceId}`
+};
+export {
+  decisionDefinitionTypeSchema,
+  decisionInstanceSchema,
+  decisionInstanceStateSchema,
+  getDecisionInstance,
+  getDecisionInstanceResponseBodySchema,
+  queryDecisionInstances,
+  queryDecisionInstancesRequestBodySchema,
+  queryDecisionInstancesResponseBodySchema
+};

package/dist/8.8/decision-requirements.d.ts

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

package/dist/8.8/decision-requirements.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { getQueryRequestBodySchema, getQueryResponseBodySchema, API_VERSION } from "../common.js";
+const decisionRequirementsSchema = z.object({
+  decisionRequirementsName: z.string(),
+  version: z.number(),
+  decisionRequirementsId: z.string(),
+  resourceName: z.string(),
+  tenantId: z.string(),
+  decisionRequirementsKey: z.string()
+});
+const queryDecisionRequirementsRequestBodySchema = getQueryRequestBodySchema({
+  sortFields: [
+    "decisionRequirementsKey",
+    "decisionRequirementsName",
+    "version",
+    "decisionRequirementsId",
+    "tenantId"
+  ],
+  filter: decisionRequirementsSchema.partial()
+});
+const queryDecisionRequirementsResponseBodySchema = getQueryResponseBodySchema(decisionRequirementsSchema);
+const getDecisionRequirementsXmlResponseBodySchema = z.string();
+const queryDecisionRequirements = {
+  method: "POST",
+  getUrl: () => `/${API_VERSION}/decision-requirements/search`
+};
+const getDecisionRequirements = {
+  method: "GET",
+  getUrl: ({ decisionRequirementsKey }) => `/${API_VERSION}/decision-requirements/${decisionRequirementsKey}`
+};
+const getDecisionRequirementsXml = {
+  method: "GET",
+  getUrl: ({ decisionRequirementsKey }) => `/${API_VERSION}/decision-requirements/${decisionRequirementsKey}/xml`
+};
+export {
+  decisionRequirementsSchema,
+  getDecisionRequirements,
+  getDecisionRequirementsXml,
+  getDecisionRequirementsXmlResponseBodySchema,
+  queryDecisionRequirements,
+  queryDecisionRequirementsRequestBodySchema,
+  queryDecisionRequirementsResponseBodySchema
+};

package/dist/8.8/document.d.ts

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