@graph-compose/core 1.0.0

package/README.md

@@ -0,0 +1,323 @@
+# @graph-compose/core
+
+Welcome! 👋 This package provides the foundational building blocks for Graph Compose: the core TypeScript types, Zod schemas, and validation logic needed to create type-safe and robust workflow graphs.
+
+> **Note:** This package provides the core definitions (TypeScript types, Zod schemas) for workflows. If you want a fluent builder API to programmatically construct and execute workflows, please use the `@graph-compose/client` package instead. This `@graph-compose/core` package is intended for developers who need to interact directly with the underlying workflow structure definitions or build custom tooling.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+- [Core Concept: The Workflow Graph](#core-concept-the-workflow-graph)
+- [Key Components](#key-components)
+  - [Nodes](#nodes)
+    - [HTTP Nodes](#http-nodes)
+    - [Agent Nodes](#agent-nodes)
+    - [Error Boundary Nodes](#error-boundary-nodes)
+    - [Iterator Nodes](#iterator-nodes)
+    - [Destination Nodes](#destination-nodes)
+  - [Tools](#tools)
+    - [HTTP Tools](#http-tools)
+    - [Graph Tools](#graph-tools)
+  - [Validation & Type Safety](#validation--type-safety)
+  - [Expressions](#expressions)
+- [API Reference & Documentation](#api-reference--documentation)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Overview
+
+The `@graph-compose/core` package helps you:
+
+*   🧩 **Define Workflows:** Structure your workflows using Nodes and Edges.
+*   🛡️ **Ensure Type Safety:** Leverage TypeScript types derived directly from validation schemas.
+*   ✅ **Validate Runtime Data:** Use powerful Zod schemas to ensure your workflow configurations are correct *before* they run.
+*   🔧 **Configure Nodes:** Define HTTP requests, agent behaviors, error handling, and more within nodes.
+*   🛠️ **Define Tools:** Create reusable tools (like HTTP calls or sub-graphs) for Agent nodes.
+*   🔄 **Use Expressions:** Safely embed dynamic values using `{{ }}` syntax within configurations (e.g., for URLs, headers).
+
+## API Reference & Documentation
+
+> **Note:** This document focuses specifically on the `@graph-compose/client` SDK for building workflows programmatically. For broader platform documentation, conceptual guides, API schemas, and examples, please visit the main Graph Compose site: [graphcompose.io](https://graphcompose.io).
+
+*   **Guides & Overviews:** For conceptual guides, integration examples, and broader platform documentation, visit the main Graph Compose documentation site: [graphcompose.io/docs](https://graphcompose.io/docs).
+*   **Workflow API Schemas:** For the definitive source of truth on the backend Workflow API request/response schemas (based on Zod/OpenAPI), see: [graphcompose.io/workflows](https://graphcompose.io/workflows).
+
+
+## Installation 
+
+```bash
+npm install @graph-compose/core
+# or
+yarn add @graph-compose/core
+```
+
+## Core Concept: The Workflow Graph
+
+Everything revolves around defining a `WorkflowGraph`. This object describes the structure and components of your workflow. You'll typically import the `WorkflowGraphSchema` to define and validate your graph.
+
+A `WorkflowGraph` primarily consists of:
+
+*   `nodes`: An array defining the steps or operations in your workflow.
+*   `tools` (optional): An array of reusable tools, often used by `AgentNode`s.
+*   `webhookUrl` (optional): A URL to notify upon workflow completion.
+*   `context` (optional): Initial data available to the workflow run.
+*   `meta` (optional): Additional metadata about the workflow.
+
+```typescript
+import { WorkflowGraphSchema, NodeSchema, ToolNodeSchema } from '@graph-compose/core';
+import { z } from 'zod';
+
+// Define the structure of your workflow
+const myWorkflowData = {
+  nodes: [
+    // ... your node definitions go here using NodeSchema ...
+    {
+      id: 'start-node',
+      type: 'http', // Example: An HTTP request node
+      dependencies: [],
+      http: {
+        config: {
+           method: 'POST',
+           url: 'https://api.example.com/data',
+           headers: { 'Content-Type': 'application/json' },
+           body: { userId: '{{ context.userId }}' } // Example expression
+        }
+      }
+    },
+    // ... other nodes
+  ],
+  tools: [
+    // ... your tool definitions go here using ToolNodeSchema ...
+    {
+      id: 'fetch-user-tool',
+      type: 'http',
+      description: 'Fetches user data',
+      http: {
+        config: {
+          method: 'GET',
+          url: 'https://api.example.com/users/{{ toolInput.userId }}'
+        }
+      }
+    },
+    // ... other tools
+  ],
+  context: {
+    initialUserId: 'user-123'
+  },
+  webhookUrl: 'https://my-service.com/workflow-updates'
+};
+
+// Validate your workflow definition
+try {
+  const validatedWorkflow = WorkflowGraphSchema.parse(myWorkflowData);
+  console.log("Workflow definition is valid!");
+  // You can now use validatedWorkflow with confidence
+} catch (error) {
+  if (error instanceof z.ZodError) {
+    console.error("Workflow validation failed:", error.errors);
+  } else {
+    console.error("An unexpected error occurred:", error);
+  }
+}
+
+// Get the inferred TypeScript type
+type MyWorkflow = z.infer<typeof WorkflowGraphSchema>;
+```
+
+## Key Components
+
+### Nodes
+
+Nodes are the individual steps in your workflow. Each node has an `id`, a `type`, and configuration specific to its type. Nodes typically declare their `dependencies` using the IDs of other nodes.
+
+#### HTTP Nodes
+
+HTTP nodes (`HttpNodeSchema`) make HTTP requests to external APIs or services.
+
+```typescript
+{
+  id: 'fetch-data',
+  type: 'http',
+  dependencies: ['auth-node'],
+  http: {
+    config: {
+      method: 'GET',
+      url: 'https://api.example.com/data',
+      headers: {
+        'Authorization': 'Bearer {{ auth-node.accessToken }}'
+      }
+    }
+  }
+}
+```
+
+#### Agent Nodes
+
+Agent nodes (`AgentNodeSchema`) can use AI agents with access to tools to perform complex tasks.
+
+```typescript
+{
+  id: 'data-analysis-agent',
+  type: 'agent',
+  dependencies: ['fetch-data'],
+  tools: ['weather-tool', 'calculate-tool'],
+  http: {
+    config: {
+      max_iterations: 5,  // Maximum number of agent thinking cycles
+      // Other agent configuration
+    }
+  }
+}
+```
+
+#### Error Boundary Nodes
+
+Error boundary nodes (`ErrorBoundaryNodeSchema`) act like try-catch blocks, handling errors from specified nodes.
+
+```typescript
+{
+  id: 'api-error-handler',
+  type: 'error_boundary',
+  protectedNodes: ['fetch-data', 'process-data'],
+  http: {
+    // Configuration for handling errors
+  }
+}
+```
+
+#### Iterator Nodes
+
+Iterator nodes (`IteratorNodeSchema`) process collections of items by creating virtual copies of downstream nodes for each item.
+
+```typescript
+{
+  id: 'process-items',
+  type: 'source_iterator',
+  http: {
+    // Configuration for the iterator
+  },
+  dependencies: []  // Iterator nodes cannot have dependencies
+}
+```
+
+#### Destination Nodes
+
+Destination nodes (`DestinationNodeSchema`) allow outputting data to specific destinations such as spreadsheets.
+
+```typescript
+{
+  id: 'save-to-sheet',
+  type: 'destination',
+  dependencies: ['process-data'],
+  http: {
+    body: {
+      sheetId: 'your-sheet-id',
+      cellValues: ['{{ process-data.result }}']
+    }
+  }
+}
+```
+
+### Tools
+
+Tools are reusable operations that can be invoked by `AgentNode`s. There are two types of tools available:
+
+#### HTTP Tools
+
+HTTP tools (`HttpToolSchema`) make HTTP requests to external services.
+
+```typescript
+{
+  id: 'weather-tool',
+  type: 'http',
+  description: 'Fetches weather data for a location',
+  http: {
+    config: {
+      method: 'GET',
+      url: 'https://api.weather.com/forecast/{{ toolInput.location }}'
+    }
+  }
+}
+```
+
+#### Graph Tools
+
+Graph tools (`GraphToolSchema`) are self-contained sub-graphs composed of multiple nodes, allowing for complex operations.
+
+```typescript
+{
+  id: 'data-processing-tool',
+  type: 'graph',
+  description: 'Processes complex datasets',
+  graph: {
+    nodes: [
+      // Array of nodes forming a sub-workflow
+      {
+        id: 'fetch-step',
+        type: 'http',
+        dependencies: [],
+        http: {
+          config: {
+            method: 'GET',
+            url: 'https://api.example.com/data/{{ toolInput.dataId }}'
+          }
+        }
+      },
+      {
+        id: 'transform-step',
+        type: 'http',
+        dependencies: ['fetch-step'],
+        http: {
+          // Configuration for transforming the data
+        }
+      }
+    ],
+    context: {
+      // Context data for the sub-graph
+    }
+  }
+}
+```
+
+### Validation & Type Safety
+
+This package uses [Zod](https://zod.dev/) schemas (`WorkflowGraphSchema`, `NodeSchema`, `ToolNodeSchema`, etc.) as the single source of truth. This gives you:
+
+1.  **Runtime Validation:** Calling `.parse()` or `.safeParse()` on a schema ensures your configuration data matches the required structure *before* you attempt to use it.
+2.  **TypeScript Types:** You can easily infer TypeScript types directly from the schemas (e.g., `z.infer<typeof WorkflowGraphSchema>`), ensuring your code interacting with these structures is type-safe.
+
+### Expressions
+
+Graph Compose supports dynamic expressions using the `{{ }}` syntax. These expressions can reference:
+
+- Node results: `{{ nodeId.property }}`
+- Context values: `{{ context.value }}`
+- Tool inputs (in tools): `{{ toolInput.value }}`
+
+Expressions support the [JSONata](https://jsonata.org/) query language for powerful data transformation capabilities.
+
+```typescript
+{
+  // Example of expressions in an HTTP config
+  http: {
+    config: {
+      method: 'POST',
+      url: 'https://api.example.com/users/{{ user-node.id }}/reports',
+      body: {
+        // Complex expression with JSONata transformation
+        summary: '{{ (reports-node.data).filter(status="complete").count() }}',
+        data: '{{ data-node.results }}'
+      }
+    }
+  }
+}
+```
+
+## Contributing
+
+Contributions are welcome! Please refer to the main repository's contribution guidelines.
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file in the main repository for details. 

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import "zod-openapi/extend";
+import { z } from "zod";
+export * from "./types";
+export { z };
+export declare const VERSION = "1.0.0";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,CAAC;AAE5B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.z = void 0;
+require("zod-openapi/extend");
+const zod_1 = require("zod");
+Object.defineProperty(exports, "z", { enumerable: true, get: function () { return zod_1.z; } });
+__exportStar(require("./types"), exports);
+// Core package exports will go here
+exports.VERSION = "1.0.0";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,8BAA4B;AAE5B,6BAAwB;AAGf,kFAHA,OAAC,OAGA;AADV,0CAAwB;AAExB,oCAAoC;AACvB,QAAA,OAAO,GAAG,OAAO,CAAC"}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/index.ts","../src/types/index.ts","../src/types/workflow.ts","../src/types/behaviors/conditions.ts","../src/types/behaviors/index.ts","../src/types/behaviors/notifications.ts","../src/types/config/activity.ts","../src/types/config/http.ts","../src/types/config/index.ts","../src/types/config/protocols.ts","../src/types/config/workflow.ts","../src/types/context/index.ts","../src/types/contracts/agents.ts","../src/types/contracts/index.ts","../src/types/contracts/tools.ts","../src/types/nodes/agents.ts","../src/types/nodes/destination.ts","../src/types/nodes/error-boundary.ts","../src/types/nodes/http.ts","../src/types/nodes/index.ts","../src/types/nodes/iterator.ts","../src/types/nodes/tools.ts","../src/types/nodes/common/base-node-schema.ts","../src/types/nodes/common/index.ts","../src/types/primitives/index.ts","../src/types/primitives/shared.ts","../src/types/results/agent.ts","../src/types/results/base.ts","../src/types/results/index.ts","../src/types/results/node.ts","../src/types/results/shared.ts","../src/types/results/source.ts","../src/types/results/tool.ts","../src/types/state/index.ts","../src/types/state/workflow-state.ts","../src/types/validation/schema.ts","../src/utils/index.ts","../src/utils/template/index.ts"],"version":"5.8.3"}

package/dist/types/behaviors/conditions.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export declare const JSONataExpressionSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const TemplatedExpressionSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const FlowControlSchema: z.ZodObject<{
+    to: z.ZodString;
+    when: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    to: string;
+    when: string;
+}, {
+    to: string;
+    when: string;
+}>;
+export declare const NodeConditionsSchema: z.ZodObject<{
+    continueTo: z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        to: z.ZodString;
+        when: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        to: string;
+        when: string;
+    }, {
+        to: string;
+        when: string;
+    }>, "many">>, {
+        to: string;
+        when: string;
+    }[] | undefined, {
+        to: string;
+        when: string;
+    }[] | undefined>;
+    terminateWhen: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    pollUntil: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    continueTo?: {
+        to: string;
+        when: string;
+    }[] | undefined;
+    terminateWhen?: string[] | undefined;
+    pollUntil?: string[] | undefined;
+}, {
+    continueTo?: {
+        to: string;
+        when: string;
+    }[] | undefined;
+    terminateWhen?: string[] | undefined;
+    pollUntil?: string[] | undefined;
+}>;
+export type FlowControl = z.infer<typeof FlowControlSchema>;
+export type NodeConditions = z.infer<typeof NodeConditionsSchema>;
+export type DeepTemplated<T> = {
+    [P in keyof T]: T[P] extends string ? string : T[P] extends object ? DeepTemplated<T[P]> : T[P];
+};
+export declare const createTemplatedObjectSchema: <T extends z.ZodType>(schema: T) => z.ZodType<DeepTemplated<z.infer<T>>>;
+//# sourceMappingURL=conditions.d.ts.map

package/dist/types/behaviors/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../../src/types/behaviors/conditions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,uBAAuB,2CAI/B,CAAC;AAGN,eAAO,MAAM,yBAAyB,2CAIjC,CAAC;AA2BN,eAAO,MAAM,iBAAiB;;;;;;;;;EAO5B,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqC7B,CAAC;AAEL,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGlE,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;KAC5B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAC/B,MAAM,GACN,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GACjB,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACnB,CAAC,CAAC,CAAC,CAAC;CACX,CAAC;AAGF,eAAO,MAAM,2BAA2B,GAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAC7D,QAAQ,CAAC,KACR,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAqBrC,CAAC"}

package/dist/types/behaviors/conditions.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTemplatedObjectSchema = exports.NodeConditionsSchema = exports.FlowControlSchema = exports.TemplatedExpressionSchema = exports.JSONataExpressionSchema = void 0;
+const zod_1 = require("zod");
+const template_1 = require("../../utils/template");
+// Base schema for pure JSONata expressions (like conditions)
+exports.JSONataExpressionSchema = zod_1.z
+    .string()
+    .refine(template_1.validateJsonataExpression, val => ({
+    message: `Invalid JSONata expression: ${val}`,
+}));
+// Schema for template strings that may contain JSONata expressions
+exports.TemplatedExpressionSchema = zod_1.z
+    .string()
+    .refine(template_1.validateTemplateExpression, val => ({
+    message: `Invalid JSONata template expression in: ${val}`,
+}));
+// Validates that a string is a single complete boolean template expression
+const validateBooleanTemplateExpression = (value) => {
+    const expression = (0, template_1.extractJsonataExpression)(value);
+    if (!expression) {
+        return false; // Must be wrapped in {{ }}
+    }
+    if (!(0, template_1.validateJsonataExpression)(expression)) {
+        return false; // Must be valid JSONata
+    }
+    return (0, template_1.validateBooleanExpression)(expression);
+};
+// Base schema for JSONata boolean conditions
+const BooleanTemplateConditionSchema = zod_1.z
+    .string()
+    .refine(validateBooleanTemplateExpression, val => ({
+    message: `Expression must be a JSONata boolean expression wrapped in {{ }}, got: ${val}`,
+}))
+    .openapi({
+    description: "JSONata boolean expression in `{{ }}` that evaluates to true/false",
+    example: "{{ status = 'completed' }}",
+});
+// Defines what happens after a node completes
+exports.FlowControlSchema = zod_1.z.object({
+    to: zod_1.z.string().openapi({
+        description: "ID of the next node to execute",
+    }),
+    when: BooleanTemplateConditionSchema.openapi({
+        description: "Boolean condition that must be true to take this path",
+    }),
+});
+// The main conditions schema that can be attached to any node
+exports.NodeConditionsSchema = zod_1.z
+    .object({
+    // Control flow
+    continueTo: zod_1.z
+        .array(exports.FlowControlSchema)
+        .optional()
+        .refine(branches => {
+        if (!branches)
+            return true;
+        return branches.every(branch => {
+            if (!branch.when)
+                return true;
+            return validateBooleanTemplateExpression(branch.when);
+        });
+    }, val => ({
+        message: `All flow control conditions must be boolean JSONata expressions wrapped in {{ }}`,
+    }))
+        .openapi({
+        description: "Defines conditional branching. An ordered list of potential next nodes. The workflow transitions to the `to` node ID of the *first* entry whose `when` condition evaluates to true based on the current node's results. If no condition matches, the workflow may end or follow default downstream paths.",
+    }),
+    terminateWhen: zod_1.z.array(BooleanTemplateConditionSchema).optional().openapi({
+        description: "Specifies conditions under which the workflow execution should halt immediately after this node completes. \nAn array of boolean [JSONata](https://jsonata.org/) expressions wrapped in `{{ }}` (e.g., `{{ status = 'error' }}`). If *any* condition evaluates to true, the entire workflow terminates.",
+    }),
+    // Async polling - updated to require boolean expression
+    pollUntil: zod_1.z.array(BooleanTemplateConditionSchema).optional().openapi({
+        description: "Enables polling behavior. \nAn array of boolean [JSONata](https://jsonata.org/) expressions wrapped in `{{ }}` (e.g., `{{ result.jobStatus = 'COMPLETED' }}`). This node will re-execute according to its retry policy as long as *all* conditions evaluate to false. Once *all* conditions evaluate to true, the workflow proceeds.",
+    }),
+})
+    .openapi({
+    ref: "NodeConditionsSchema",
+    description: "Node Conditions represent conditional logic that determines the next step in a workflow. All conditions must be boolean JSONata expressions wrapped in `{{ }}`",
+    "x-tags": ["Behaviors"],
+});
+// Helper schema for validating objects that may contain templated expressions
+const createTemplatedObjectSchema = (schema) => {
+    const processObject = (obj) => {
+        if (obj instanceof zod_1.z.ZodString) {
+            return exports.TemplatedExpressionSchema;
+        }
+        if (obj instanceof zod_1.z.ZodObject) {
+            const newShape = Object.fromEntries(Object.entries(obj.shape).map(([key, value]) => [
+                key,
+                processObject(value),
+            ]));
+            return zod_1.z.object(newShape);
+        }
+        if (obj instanceof zod_1.z.ZodArray) {
+            return zod_1.z.array(processObject(obj.element));
+        }
+        return obj;
+    };
+    return processObject(schema);
+};
+exports.createTemplatedObjectSchema = createTemplatedObjectSchema;
+//# sourceMappingURL=conditions.js.map

package/dist/types/behaviors/conditions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.js","sourceRoot":"","sources":["../../../src/types/behaviors/conditions.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,mDAK8B;AAE9B,6DAA6D;AAChD,QAAA,uBAAuB,GAAG,OAAC;KACrC,MAAM,EAAE;KACR,MAAM,CAAC,oCAAyB,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IACzC,OAAO,EAAE,+BAA+B,GAAG,EAAE;CAC9C,CAAC,CAAC,CAAC;AAEN,mEAAmE;AACtD,QAAA,yBAAyB,GAAG,OAAC;KACvC,MAAM,EAAE;KACR,MAAM,CAAC,qCAA0B,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IAC1C,OAAO,EAAE,2CAA2C,GAAG,EAAE;CAC1D,CAAC,CAAC,CAAC;AAEN,2EAA2E;AAC3E,MAAM,iCAAiC,GAAG,CAAC,KAAa,EAAW,EAAE;IACnE,MAAM,UAAU,GAAG,IAAA,mCAAwB,EAAC,KAAK,CAAC,CAAC;IACnD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,KAAK,CAAC,CAAC,2BAA2B;IAC3C,CAAC;IACD,IAAI,CAAC,IAAA,oCAAyB,EAAC,UAAU,CAAC,EAAE,CAAC;QAC3C,OAAO,KAAK,CAAC,CAAC,wBAAwB;IACxC,CAAC;IACD,OAAO,IAAA,oCAAyB,EAAC,UAAU,CAAC,CAAC;AAC/C,CAAC,CAAC;AAEF,6CAA6C;AAC7C,MAAM,8BAA8B,GAAG,OAAC;KACrC,MAAM,EAAE;KACR,MAAM,CAAC,iCAAiC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IACjD,OAAO,EAAE,0EAA0E,GAAG,EAAE;CACzF,CAAC,CAAC;KACF,OAAO,CAAC;IACP,WAAW,EACT,oEAAoE;IACtE,OAAO,EAAE,4BAA4B;CACtC,CAAC,CAAC;AAEL,8CAA8C;AACjC,QAAA,iBAAiB,GAAG,OAAC,CAAC,MAAM,CAAC;IACxC,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC;QACrB,WAAW,EAAE,gCAAgC;KAC9C,CAAC;IACF,IAAI,EAAE,8BAA8B,CAAC,OAAO,CAAC;QAC3C,WAAW,EAAE,uDAAuD;KACrE,CAAC;CACH,CAAC,CAAC;AAEH,8DAA8D;AACjD,QAAA,oBAAoB,GAAG,OAAC;KAClC,MAAM,CAAC;IACN,eAAe;IACf,UAAU,EAAE,OAAC;SACV,KAAK,CAAC,yBAAiB,CAAC;SACxB,QAAQ,EAAE;SACV,MAAM,CACL,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC;QAC3B,OAAO,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;YAC7B,IAAI,CAAC,MAAM,CAAC,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC9B,OAAO,iCAAiC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;IACL,CAAC,EACD,GAAG,CAAC,EAAE,CAAC,CAAC;QACN,OAAO,EAAE,kFAAkF;KAC5F,CAAC,CACH;SACA,OAAO,CAAC;QACP,WAAW,EACT,2SAA2S;KAC9S,CAAC;IACJ,aAAa,EAAE,OAAC,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC;QACxE,WAAW,EACT,ySAAyS;KAC5S,CAAC;IACF,wDAAwD;IACxD,SAAS,EAAE,OAAC,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC;QACpE,WAAW,EACT,sUAAsU;KACzU,CAAC;CACH,CAAC;KACD,OAAO,CAAC;IACP,GAAG,EAAE,sBAAsB;IAC3B,WAAW,EACT,gKAAgK;IAClK,QAAQ,EAAE,CAAC,WAAW,CAAC;CACxB,CAAC,CAAC;AAcL,8EAA8E;AACvE,MAAM,2BAA2B,GAAG,CACzC,MAAS,EAC6B,EAAE;IACxC,MAAM,aAAa,GAAG,CAAC,GAAQ,EAAO,EAAE;QACtC,IAAI,GAAG,YAAY,OAAC,CAAC,SAAS,EAAE,CAAC;YAC/B,OAAO,iCAAyB,CAAC;QACnC,CAAC;QACD,IAAI,GAAG,YAAY,OAAC,CAAC,SAAS,EAAE,CAAC;YAC/B,MAAM,QAAQ,GAAG,MAAM,CAAC,WAAW,CACjC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC;gBAC9C,GAAG;gBACH,aAAa,CAAC,KAAK,CAAC;aACrB,CAAC,CACH,CAAC;YACF,OAAO,OAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC5B,CAAC;QACD,IAAI,GAAG,YAAY,OAAC,CAAC,QAAQ,EAAE,CAAC;YAC9B,OAAO,OAAC,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;QAC7C,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;IAEF,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC;AAC/B,CAAC,CAAC;AAvBW,QAAA,2BAA2B,+BAuBtC"}

package/dist/types/behaviors/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./conditions";
+export * from "./notifications";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/behaviors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/behaviors/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC"}

package/dist/types/behaviors/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./conditions"), exports);
+__exportStar(require("./notifications"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/behaviors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/behaviors/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA6B;AAC7B,kDAAgC"}