@dxos/plugin-automation 0.8.4-main.fffef41 → 0.9.0

package/dist/types/src/testing/test-functions.d.ts

@@ -1,13 +1,328 @@
-import { Type } from '@dxos/echo';
+import { DXN } from '@dxos/echo';
+/**
+ * Operations seeded into the local space in stories.
+ */
 export declare const functions: ({
+    key: DXN.DXN;
     name: string;
     version: string;
-    inputSchema: Type.JsonSchema;
+    inputSchema: {
+        $id?: string | undefined;
+        $schema?: string | undefined;
+        $ref?: string | undefined;
+        $comment?: string | undefined;
+        entityKind?: import("@dxos/echo/internal").EntityKind | undefined;
+        typename?: string | undefined;
+        version?: string | undefined;
+        relationTarget?: /*elided*/ any | undefined;
+        relationSource?: /*elided*/ any | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        readOnly?: boolean | undefined;
+        writeOnly?: boolean | undefined;
+        examples?: any[] | undefined;
+        default?: any;
+        const?: any;
+        enum?: any[] | undefined;
+        type?: "array" | "boolean" | "integer" | "null" | "number" | "object" | "string" | ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string")[] | undefined;
+        multipleOf?: number | undefined;
+        maximum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minimum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        format?: string | undefined;
+        minLength?: number | undefined;
+        items?: /*elided*/ any[] | /*elided*/ any | undefined;
+        additionalItems?: boolean | /*elided*/ any | undefined;
+        maxItems?: number | undefined;
+        minItems?: number | undefined;
+        uniqueItems?: boolean | undefined;
+        contains?: /*elided*/ any | undefined;
+        maxProperties?: number | undefined;
+        minProperties?: number | undefined;
+        required?: string[] | undefined;
+        propertyOrder?: string[] | undefined;
+        additionalProperties?: boolean | /*elided*/ any | undefined;
+        properties?: {
+            [x: string]: /*elided*/ any;
+        } | undefined;
+        patternProperties?: {
+            [x: string]: any;
+        } | undefined;
+        propertyNames?: /*elided*/ any | undefined;
+        definitions?: {
+            [x: string]: any;
+        } | undefined;
+        dependencies?: {
+            [x: string]: string | string[] | /*elided*/ any;
+        } | undefined;
+        contentMediaType?: string | undefined;
+        contentEncoding?: string | undefined;
+        if?: /*elided*/ any | undefined;
+        then?: /*elided*/ any | undefined;
+        else?: /*elided*/ any | undefined;
+        allOf?: /*elided*/ any[] | undefined;
+        anyOf?: /*elided*/ any[] | undefined;
+        oneOf?: /*elided*/ any[] | undefined;
+        not?: /*elided*/ any | undefined;
+        $defs?: {
+            [x: string]: any;
+        } | undefined;
+        currency?: string | undefined;
+        reference?: {
+            schema: /*elided*/ any;
+            schemaVersion?: string | undefined;
+            schemaObject?: string | undefined;
+        } | undefined;
+        annotations?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+        echo?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+    };
     binding?: undefined;
 } | {
+    key: DXN.DXN;
     name: string;
     version: string;
     binding: string;
-    inputSchema: Type.JsonSchema;
+    inputSchema: {
+        $id?: string | undefined;
+        $schema?: string | undefined;
+        $ref?: string | undefined;
+        $comment?: string | undefined;
+        entityKind?: import("@dxos/echo/internal").EntityKind | undefined;
+        typename?: string | undefined;
+        version?: string | undefined;
+        relationTarget?: any | undefined;
+        relationSource?: any | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        readOnly?: boolean | undefined;
+        writeOnly?: boolean | undefined;
+        examples?: any[] | undefined;
+        default?: any;
+        const?: any;
+        enum?: any[] | undefined;
+        type?: "array" | "boolean" | "integer" | "null" | "number" | "object" | "string" | ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string")[] | undefined;
+        multipleOf?: number | undefined;
+        maximum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minimum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        format?: string | undefined;
+        minLength?: number | undefined;
+        items?: any[] | any | undefined;
+        additionalItems?: boolean | any | undefined;
+        maxItems?: number | undefined;
+        minItems?: number | undefined;
+        uniqueItems?: boolean | undefined;
+        contains?: any | undefined;
+        maxProperties?: number | undefined;
+        minProperties?: number | undefined;
+        required?: string[] | undefined;
+        propertyOrder?: string[] | undefined;
+        additionalProperties?: boolean | any | undefined;
+        properties?: {
+            [x: string]: any;
+        } | undefined;
+        patternProperties?: {
+            [x: string]: any;
+        } | undefined;
+        propertyNames?: any | undefined;
+        definitions?: {
+            [x: string]: any;
+        } | undefined;
+        dependencies?: {
+            [x: string]: string | string[] | any;
+        } | undefined;
+        contentMediaType?: string | undefined;
+        contentEncoding?: string | undefined;
+        if?: any | undefined;
+        then?: any | undefined;
+        else?: any | undefined;
+        allOf?: any[] | undefined;
+        anyOf?: any[] | undefined;
+        oneOf?: any[] | undefined;
+        not?: any | undefined;
+        $defs?: {
+            [x: string]: any;
+        } | undefined;
+        currency?: string | undefined;
+        reference?: {
+            schema: any;
+            schemaVersion?: string | undefined;
+            schemaObject?: string | undefined;
+        } | undefined;
+        annotations?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+        echo?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+    };
 })[];
+/**
+ * Operations seeded into the registry (not the local space) in stories.
+ * Simulates built-in or plugin-provided operations available globally.
+ */
+export declare const registryFunctions: {
+    key: string;
+    name: string;
+    version: string;
+    inputSchema: {
+        $id?: string | undefined;
+        $schema?: string | undefined;
+        $ref?: string | undefined;
+        $comment?: string | undefined;
+        entityKind?: import("@dxos/echo/internal").EntityKind | undefined;
+        typename?: string | undefined;
+        version?: string | undefined;
+        relationTarget?: /*elided*/ any | undefined;
+        relationSource?: /*elided*/ any | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        readOnly?: boolean | undefined;
+        writeOnly?: boolean | undefined;
+        examples?: any[] | undefined;
+        default?: any;
+        const?: any;
+        enum?: any[] | undefined;
+        type?: "array" | "boolean" | "integer" | "null" | "number" | "object" | "string" | ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string")[] | undefined;
+        multipleOf?: number | undefined;
+        maximum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minimum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        format?: string | undefined;
+        minLength?: number | undefined;
+        items?: /*elided*/ any[] | /*elided*/ any | undefined;
+        additionalItems?: boolean | /*elided*/ any | undefined;
+        maxItems?: number | undefined;
+        minItems?: number | undefined;
+        uniqueItems?: boolean | undefined;
+        contains?: /*elided*/ any | undefined;
+        maxProperties?: number | undefined;
+        minProperties?: number | undefined;
+        required?: string[] | undefined;
+        propertyOrder?: string[] | undefined;
+        additionalProperties?: boolean | /*elided*/ any | undefined;
+        properties?: {
+            [x: string]: /*elided*/ any;
+        } | undefined;
+        patternProperties?: {
+            [x: string]: any;
+        } | undefined;
+        propertyNames?: /*elided*/ any | undefined;
+        definitions?: {
+            [x: string]: any;
+        } | undefined;
+        dependencies?: {
+            [x: string]: string | string[] | /*elided*/ any;
+        } | undefined;
+        contentMediaType?: string | undefined;
+        contentEncoding?: string | undefined;
+        if?: /*elided*/ any | undefined;
+        then?: /*elided*/ any | undefined;
+        else?: /*elided*/ any | undefined;
+        allOf?: /*elided*/ any[] | undefined;
+        anyOf?: /*elided*/ any[] | undefined;
+        oneOf?: /*elided*/ any[] | undefined;
+        not?: /*elided*/ any | undefined;
+        $defs?: {
+            [x: string]: any;
+        } | undefined;
+        currency?: string | undefined;
+        reference?: {
+            schema: /*elided*/ any;
+            schemaVersion?: string | undefined;
+            schemaObject?: string | undefined;
+        } | undefined;
+        annotations?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+        echo?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+    };
+}[];
 //# sourceMappingURL=test-functions.d.ts.map

package/dist/types/src/testing/test-functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-functions.d.ts","sourceRoot":"","sources":["../../../../src/testing/test-functions.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,eAAO,MAAM,SAAS;;;;;;;;;;IAgCrB,CAAC"}
+{"version":3,"file":"test-functions.d.ts","sourceRoot":"","sources":["../../../../src/testing/test-functions.ts"],"names":[],"mappings":"AAOA,OAAO,EAAmB,GAAG,EAAE,MAAM,YAAY,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmCrB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsB7B,CAAC"}

package/dist/types/src/testing.d.ts

@@ -0,0 +1,2 @@
+export * from './AutomationPlugin';
+//# sourceMappingURL=testing.d.ts.map

package/dist/types/src/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../../src/testing.ts"],"names":[],"mappings":"AAMA,cAAc,oBAAoB,CAAC"}

package/dist/types/src/translations.d.ts

@@ -1,36 +1,95 @@
-import { meta } from './meta';
 export declare const translations: [{
     readonly 'en-US': {
-        readonly [meta.id]: {
-            readonly 'plugin name': "Automation";
-            readonly 'automation panel label': "Automations";
-            readonly 'script automation label': "Automation";
-            readonly 'automation verbose label': "Manage automations";
-            readonly 'automation description': "You can manage all the triggers which automate your space here.";
-            readonly 'runtime label': "Enable Local Runtime";
-            readonly 'runtime description': "This will start a trigger dispatcher locally for this space to run triggers on your device while Composer is running.";
-            readonly 'functions panel label': "Functions";
-            readonly 'functions verbose label': "Manage deployed functions";
-            readonly 'functions registry verbose label': "Functions registry";
-            readonly 'functions registry description': "Import functions from the registry";
-            readonly 'functions description': "You can manage all the functions deployed from your space on EDGE here.";
-            readonly 'function copy id': "Copy Function ID";
-            readonly 'no functions found': "No functions found";
-            readonly 'go to function source button label': "Show function source";
-            readonly 'delete function button label': "Delete function";
-            readonly 'trigger editor title': "Configure Trigger";
-            readonly 'new trigger label': "Add Trigger";
-            readonly 'trigger type timer': "Timer";
-            readonly 'trigger type webhook': "Webhook";
-            readonly 'trigger type websocket': "Websocket";
-            readonly 'trigger type subscription': "Subscription";
-            readonly 'trigger type email': "Email";
-            readonly 'trigger type queue': "Queue";
-            readonly 'trigger copy url': "Copy URL";
-            readonly 'trigger copy email': "Copy Email";
-            readonly 'trigger payload add': "Add";
-            readonly 'trigger payload remove': "Remove";
-            readonly 'trigger payload prop name placeholder': "New payload property name";
+        readonly [x: string]: {
+            readonly 'typename.label': 'Automation';
+            readonly 'typename.label_zero': 'Automations';
+            readonly 'typename.label_one': 'Automation';
+            readonly 'typename.label_other': 'Automations';
+            readonly 'object-name.placeholder': 'New automation';
+            readonly 'add-object.label': 'Add automation';
+            readonly 'rename-object.label': 'Rename automation';
+            readonly 'delete-object.label': 'Delete automation';
+            readonly 'plugin.name'?: undefined;
+            readonly 'automation-panel.label'?: undefined;
+            readonly 'create-panel.template.placeholder'?: undefined;
+            readonly 'automation-name.label'?: undefined;
+            readonly 'general.title'?: undefined;
+            readonly 'general.description'?: undefined;
+            readonly 'action.title'?: undefined;
+            readonly 'action.description'?: undefined;
+            readonly 'action.placeholder'?: undefined;
+            readonly 'action-input.label'?: undefined;
+            readonly 'action-kind.operation.label'?: undefined;
+            readonly 'action-kind.routine.label'?: undefined;
+            readonly 'trigger-picker.title'?: undefined;
+            readonly 'trigger-picker.description'?: undefined;
+            readonly 'trigger-kind.placeholder'?: undefined;
+            readonly 'trigger-kind.timer.label'?: undefined;
+            readonly 'trigger-kind.feed.label'?: undefined;
+            readonly 'cron.placeholder'?: undefined;
+            readonly 'feed.placeholder'?: undefined;
+            readonly 'enabled.label'?: undefined;
+            readonly 'enabled.description'?: undefined;
+            readonly 'add-trigger.label'?: undefined;
+            readonly 'add-trigger-first.message'?: undefined;
+            readonly 'remove-trigger.label'?: undefined;
+            readonly 'select-action-first.message'?: undefined;
+            readonly 'automation-companion.label'?: undefined;
+            readonly 'no-automations.message'?: undefined;
+            readonly 'automation-not-associated.message'?: undefined;
+            readonly 'automation-detached.message'?: undefined;
+            readonly 'automation-verbose.label'?: undefined;
+            readonly 'automation.description'?: undefined;
+            readonly 'runtime.label'?: undefined;
+            readonly 'runtime.description'?: undefined;
+            readonly 'runtime.disabled.label'?: undefined;
+            readonly 'runtime.local.label'?: undefined;
+            readonly 'runtime.edge.label'?: undefined;
+        } | {
+            readonly 'typename.label'?: undefined;
+            readonly 'typename.label_zero'?: undefined;
+            readonly 'typename.label_one'?: undefined;
+            readonly 'typename.label_other'?: undefined;
+            readonly 'object-name.placeholder'?: undefined;
+            readonly 'add-object.label'?: undefined;
+            readonly 'rename-object.label'?: undefined;
+            readonly 'delete-object.label'?: undefined;
+            readonly 'plugin.name': 'Automation';
+            readonly 'automation-panel.label': 'Automations';
+            readonly 'create-panel.template.placeholder': 'Search templates...';
+            readonly 'automation-name.label': 'Name';
+            readonly 'general.title': 'General';
+            readonly 'general.description': 'Name and status.';
+            readonly 'action.title': 'Action';
+            readonly 'action.description': 'What this automation runs.';
+            readonly 'action.placeholder': 'Select an operation or routine';
+            readonly 'action-input.label': 'Input';
+            readonly 'action-kind.operation.label': 'Operation';
+            readonly 'action-kind.routine.label': 'Routine';
+            readonly 'trigger-picker.title': 'Trigger';
+            readonly 'trigger-picker.description': 'When this automation runs.';
+            readonly 'trigger-kind.placeholder': 'Select trigger type';
+            readonly 'trigger-kind.timer.label': 'Schedule (cron)';
+            readonly 'trigger-kind.feed.label': 'Feed';
+            readonly 'cron.placeholder': '0 0 * * *';
+            readonly 'feed.placeholder': 'Select a feed';
+            readonly 'enabled.label': 'Enabled';
+            readonly 'enabled.description': 'Turn this automation on or off.';
+            readonly 'add-trigger.label': 'Add trigger';
+            readonly 'add-trigger-first.message': 'Add a trigger to enable.';
+            readonly 'remove-trigger.label': 'Remove';
+            readonly 'select-action-first.message': 'Select an action first.';
+            readonly 'automation-companion.label': 'Automation';
+            readonly 'no-automations.message': 'No automations for this object.';
+            readonly 'automation-not-associated.message': 'Not yet associated with this object.';
+            readonly 'automation-detached.message': 'No longer associated with this object.';
+            readonly 'automation-verbose.label': 'Manage automations';
+            readonly 'automation.description': 'Manage where automations in this space run.';
+            readonly 'runtime.label': 'Runtime location';
+            readonly 'runtime.description': 'Determines where automations in this space run.';
+            readonly 'runtime.disabled.label': 'Disabled';
+            readonly 'runtime.local.label': 'Local';
+            readonly 'runtime.edge.label': 'EDGE (experimental)';
         };
     };
 }];

package/dist/types/src/translations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/translations.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,eAAO,MAAM,YAAY;;QAGnB,SAAA,CAAC,IAAI,CAAC,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoCR;;EAGwB,CAAC"}
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/translations.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY;;;uCAIC,YAAY;4CACP,aAAa;2CACd,YAAY;6CACV,aAAa;gDACV,gBAAgB;yCACvB,gBAAgB;4CACb,mBAAmB;4CACnB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAG3B,YAAY;+CACD,aAAa;0DACF,qBAAqB;8CAEjC,MAAM;sCACd,SAAS;4CACH,kBAAkB;qCACzB,QAAQ;2CACF,4BAA4B;2CAC5B,gCAAgC;2CAChC,OAAO;oDACE,WAAW;kDACb,SAAS;6CACd,SAAS;mDACH,4BAA4B;iDAC9B,qBAAqB;iDACrB,iBAAiB;gDAClB,MAAM;yCACb,WAAW;yCACX,eAAe;sCAClB,SAAS;4CACH,iCAAiC;0CACnC,aAAa;kDACL,0BAA0B;6CAC/B,QAAQ;oDACD,yBAAyB;mDAC1B,YAAY;+CAChB,iCAAiC;0DACtB,sCAAsC;oDAC5C,wCAAwC;iDAE3C,oBAAoB;+CACtB,6CAA6C;sCAEtD,kBAAkB;4CACZ,iDAAiD;+CAC9C,UAAU;4CACb,OAAO;2CACR,qBAAqB;;;EAIpB,CAAC"}

package/dist/types/src/types/Automation.d.ts

@@ -0,0 +1,41 @@
+import * as Schema from 'effect/Schema';
+import { Obj, Type } from '@dxos/echo';
+/**
+ * User-facing automation: a thin aggregate of an action (`runnable`) and the triggers that fire it.
+ * App-level only — EDGE stays unaware of it (triggers point directly at the runnable).
+ */
+export declare const Automation: Type.Obj<{
+    readonly name?: string | undefined;
+    readonly description?: string | undefined;
+    readonly runnable?: import("@dxos/echo/internal").Ref<{
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly updated?: string | undefined;
+        readonly source?: import("@dxos/echo/internal").Ref<Obj.Unknown> | undefined;
+        readonly inputSchema?: import("@dxos/echo/internal").JsonSchemaType | undefined;
+        readonly outputSchema?: import("@dxos/echo/internal").JsonSchemaType | undefined;
+        readonly services?: readonly string[] | undefined;
+        readonly binding?: string | undefined;
+        readonly icon?: string | undefined;
+    } & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown> | undefined;
+    readonly triggers: readonly import("@dxos/echo/internal").Ref<Obj.Unknown>[];
+}, Schema.Struct.Fields>;
+export type Automation = Type.InstanceType<typeof Automation>;
+export declare const instanceOf: (value: unknown) => value is Automation;
+export declare const make: (props: Obj.MakeProps<typeof Automation>) => Obj.OfShape<{
+    readonly name?: string | undefined;
+    readonly description?: string | undefined;
+    readonly runnable?: import("@dxos/echo/internal").Ref<{
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly updated?: string | undefined;
+        readonly source?: import("@dxos/echo/internal").Ref<Obj.Unknown> | undefined;
+        readonly inputSchema?: import("@dxos/echo/internal").JsonSchemaType | undefined;
+        readonly outputSchema?: import("@dxos/echo/internal").JsonSchemaType | undefined;
+        readonly services?: readonly string[] | undefined;
+        readonly binding?: string | undefined;
+        readonly icon?: string | undefined;
+    } & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown> | undefined;
+    readonly triggers: readonly import("@dxos/echo/internal").Ref<Obj.Unknown>[];
+} & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object>>;
+//# sourceMappingURL=Automation.d.ts.map

package/dist/types/src/types/Automation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Automation.d.ts","sourceRoot":"","sources":["../../../../src/types/Automation.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAmB,GAAG,EAAO,IAAI,EAAE,MAAM,YAAY,CAAC;AAK7D;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;wBAqBtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9D,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,UAA+C,CAAC;AAErG,eAAO,MAAM,IAAI,UAAW,GAAG,CAAC,SAAS,CAAC,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;wFAAgC,CAAC"}

package/dist/types/src/types/Automation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Automation.test.d.ts.map

package/dist/types/src/types/Automation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Automation.test.d.ts","sourceRoot":"","sources":["../../../../src/types/Automation.test.ts"],"names":[],"mappings":""}

package/dist/types/src/types/AutomationCapabilities.d.ts

@@ -0,0 +1,42 @@
+import type * as Effect from 'effect/Effect';
+import { Capability } from '@dxos/app-framework';
+import type { Database, Obj } from '@dxos/echo';
+import { type DelegationStrategy } from '@dxos/functions-runtime';
+import * as Automation from './Automation';
+/**
+ * Optional supervisor strategy for the agent chat service. When contributed (by a plugin that knows
+ * the agent/plan model, e.g. plugin-assistant), the conversational agent delegates outstanding work
+ * to sub-agents and folds their results back into the conversation. Consumed by the AgentService
+ * LayerSpec; absent by default (a plain conversational agent).
+ */
+export declare const AgentDelegationStrategy: Capability.InterfaceDef<DelegationStrategy>;
+/**
+ * An automation template contributed by a plugin. The create dialog and the per-object "Automations"
+ * companion list contributed templates (`Capability.getAll(AutomationCapabilities.Template)`) and run the
+ * chosen template's `scaffold` to build the automation.
+ */
+export type Template = {
+    /** Stable id (e.g. 'org.dxos.automation.blank'). */
+    id: string;
+    /** Human-readable label shown in the picker. */
+    label: string;
+    /** Optional Phosphor icon name. */
+    icon?: string;
+    /**
+     * Whether this template applies to the given companion subject. The subject is the object whose
+     * "Automations" companion is open, or undefined in the global create dialog. Templates that need a
+     * specific subject (e.g. a feed-bearing Mailbox) gate themselves here. Defaults to always-applies.
+     */
+    appliesTo?: (subject?: Obj.Unknown) => boolean;
+    /**
+     * Build the Automation from the user's input. The returned Automation is added to the database by the
+     * create flow; any auxiliary objects (runnable, triggers) must be added by the scaffold itself via
+     * Database.Service. `subject` is set when scaffolding from an object's companion.
+     */
+    scaffold: (ctx: {
+        name?: string;
+        subject?: Obj.Unknown;
+    }) => Effect.Effect<Automation.Automation, Error, Database.Service>;
+};
+export declare const Template: Capability.InterfaceDef<Template>;
+//# sourceMappingURL=AutomationCapabilities.d.ts.map

package/dist/types/src/types/AutomationCapabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutomationCapabilities.d.ts","sourceRoot":"","sources":["../../../../src/types/AutomationCapabilities.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,6CAEnC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,oDAAoD;IACpD,EAAE,EAAE,MAAM,CAAC;IACX,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,OAAO,KAAK,OAAO,CAAC;IAC/C;;;;OAIG;IACH,QAAQ,EAAE,CAAC,GAAG,EAAE;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC;KACvB,KAAK,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;CACrE,CAAC;AAEF,eAAO,MAAM,QAAQ,mCAA8E,CAAC"}

package/dist/types/src/types/AutomationOperation.d.ts

@@ -0,0 +1,31 @@
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Database, Obj } from '@dxos/echo';
+import { EID as _EchoURIReference } from '@dxos/keys';
+export { _EchoURIReference };
+export declare const CreateTriggerFromTemplate: Operation.Definition<{
+    readonly db: Database.Database;
+    readonly template: {
+        readonly type: "timer";
+        readonly cron: string;
+    } | {
+        readonly type: "feed";
+        readonly feed: any;
+    };
+    readonly enabled?: boolean | undefined;
+    readonly scriptName?: string | undefined;
+    readonly input?: {
+        readonly [x: string]: any;
+    } | undefined;
+}, void, Capability.Service>;
+export declare const CreateAutomation: Operation.Definition<{
+    readonly db: Database.Database;
+    readonly templateId: string;
+    readonly name?: string | undefined;
+    readonly subject?: Obj.Unknown | undefined;
+}, {
+    readonly id: string;
+    readonly subject: readonly string[];
+    readonly object: Obj.Unknown;
+}, Capability.Service>;
+//# sourceMappingURL=AutomationOperation.d.ts.map

package/dist/types/src/types/AutomationOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutomationOperation.d.ts","sourceRoot":"","sources":["../../../../src/types/AutomationOperation.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAO,GAAG,EAAE,MAAM,YAAY,CAAC;AAIhD,OAAO,EAAE,GAAG,IAAI,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAKtD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAI7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;4BAepC,CAAC;AAIH,eAAO,MAAM,gBAAgB;;;;;;;;;sBAkB3B,CAAC"}

package/dist/types/src/types/Runnable.d.ts

@@ -0,0 +1,14 @@
+import { Operation } from '@dxos/compute';
+export type Runnable = Operation.PersistentOperation;
+export declare const Runnable: import("@dxos/echo/Type").Obj<{
+    readonly name: string;
+    readonly description?: string | undefined;
+    readonly updated?: string | undefined;
+    readonly source?: import("@dxos/echo/internal").Ref<import("@dxos/echo/Obj").Unknown> | undefined;
+    readonly inputSchema?: import("@dxos/echo/internal").JsonSchemaType | undefined;
+    readonly outputSchema?: import("@dxos/echo/internal").JsonSchemaType | undefined;
+    readonly services?: readonly string[] | undefined;
+    readonly binding?: string | undefined;
+    readonly icon?: string | undefined;
+}, import("effect/Schema").Struct.Fields>;
+//# sourceMappingURL=Runnable.d.ts.map

package/dist/types/src/types/Runnable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Runnable.d.ts","sourceRoot":"","sources":["../../../../src/types/Runnable.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAM1C,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,mBAAmB,CAAC;AACrD,eAAO,MAAM,QAAQ;;;;;;;;;;yCAAgC,CAAC"}

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

@@ -1,2 +1,6 @@
 export * from './schema';
+export * as Automation from './Automation';
+export * as AutomationCapabilities from './AutomationCapabilities';
+export * as AutomationOperation from './AutomationOperation';
+export * as Runnable from './Runnable';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AAEzB,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,sBAAsB,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,mBAAmB,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC"}