@dxos/plugin-automation 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

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

@@ -1,43 +1,30 @@
+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: {
-        properties?: {
-            [x: string]: /*elided*/ any;
-        } | undefined;
-        type?: "string" | "number" | "boolean" | "object" | "array" | "integer" | "null" | ("string" | "number" | "boolean" | "object" | "array" | "integer" | "null")[] | undefined;
-        typename?: string | undefined;
-        version?: string | undefined;
-        description?: string | undefined;
-        default?: any;
-        annotations?: {
-            type?: {
-                typename: string;
-                version: string;
-                schemaId?: string | undefined;
-            } | undefined;
-            annotations?: {
-                [x: string]: any;
-            } | undefined;
-            meta?: {
-                [x: string]: any;
-            } | undefined;
-            labelProp?: import("@dxos/effect").JsonPath | import("@dxos/effect").JsonPath[] | undefined;
-            generator?: string | [string, number] | undefined;
-        } | undefined;
-        title?: string | undefined;
         $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;
@@ -47,7 +34,7 @@ export declare const functions: ({
         pattern?: string | undefined;
         format?: string | undefined;
         minLength?: number | undefined;
-        items?: /*elided*/ any | /*elided*/ any[] | undefined;
+        items?: /*elided*/ any[] | /*elided*/ any | undefined;
         additionalItems?: boolean | /*elided*/ any | undefined;
         maxItems?: number | undefined;
         minItems?: number | undefined;
@@ -58,12 +45,15 @@ export declare const functions: ({
         required?: string[] | undefined;
         propertyOrder?: string[] | undefined;
         additionalProperties?: boolean | /*elided*/ any | undefined;
-        patternProperties?: {
+        properties?: {
             [x: string]: /*elided*/ any;
         } | undefined;
+        patternProperties?: {
+            [x: string]: any;
+        } | undefined;
         propertyNames?: /*elided*/ any | undefined;
         definitions?: {
-            [x: string]: /*elided*/ any;
+            [x: string]: any;
         } | undefined;
         dependencies?: {
             [x: string]: string | string[] | /*elided*/ any;
@@ -78,7 +68,7 @@ export declare const functions: ({
         oneOf?: /*elided*/ any[] | undefined;
         not?: /*elided*/ any | undefined;
         $defs?: {
-            [x: string]: /*elided*/ any;
+            [x: string]: any;
         } | undefined;
         currency?: string | undefined;
         reference?: {
@@ -86,7 +76,12 @@ export declare const functions: ({
             schemaVersion?: string | undefined;
             schemaObject?: string | undefined;
         } | undefined;
-        echo?: {
+        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;
@@ -95,28 +90,105 @@ export declare const functions: ({
             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;
-            labelProp?: import("@dxos/effect").JsonPath | import("@dxos/effect").JsonPath[] | undefined;
-            generator?: string | [string, number] | 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: {
-        properties?: {
-            [x: string]: /*elided*/ any;
-        } | undefined;
-        type?: "string" | "number" | "boolean" | "object" | "array" | "integer" | "null" | ("string" | "number" | "boolean" | "object" | "array" | "integer" | "null")[] | undefined;
+        $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;
@@ -125,25 +197,51 @@ export declare const functions: ({
             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;
-            labelProp?: import("@dxos/effect").JsonPath | import("@dxos/effect").JsonPath[] | undefined;
-            generator?: string | [string, number] | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
         } | undefined;
-        title?: string | 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;
@@ -153,7 +251,7 @@ export declare const functions: ({
         pattern?: string | undefined;
         format?: string | undefined;
         minLength?: number | undefined;
-        items?: /*elided*/ any | /*elided*/ any[] | undefined;
+        items?: /*elided*/ any[] | /*elided*/ any | undefined;
         additionalItems?: boolean | /*elided*/ any | undefined;
         maxItems?: number | undefined;
         minItems?: number | undefined;
@@ -164,12 +262,15 @@ export declare const functions: ({
         required?: string[] | undefined;
         propertyOrder?: string[] | undefined;
         additionalProperties?: boolean | /*elided*/ any | undefined;
-        patternProperties?: {
+        properties?: {
             [x: string]: /*elided*/ any;
         } | undefined;
+        patternProperties?: {
+            [x: string]: any;
+        } | undefined;
         propertyNames?: /*elided*/ any | undefined;
         definitions?: {
-            [x: string]: /*elided*/ any;
+            [x: string]: any;
         } | undefined;
         dependencies?: {
             [x: string]: string | string[] | /*elided*/ any;
@@ -184,7 +285,7 @@ export declare const functions: ({
         oneOf?: /*elided*/ any[] | undefined;
         not?: /*elided*/ any | undefined;
         $defs?: {
-            [x: string]: /*elided*/ any;
+            [x: string]: any;
         } | undefined;
         currency?: string | undefined;
         reference?: {
@@ -192,7 +293,12 @@ export declare const functions: ({
             schemaVersion?: string | undefined;
             schemaObject?: string | undefined;
         } | undefined;
-        echo?: {
+        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;
@@ -201,12 +307,22 @@ export declare const functions: ({
             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;
-            labelProp?: import("@dxos/effect").JsonPath | import("@dxos/effect").JsonPath[] | undefined;
-            generator?: string | [string, number] | 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":"AASA,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,38 +1,50 @@
-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 'function parameters label': "Function parameters";
-            readonly 'trigger editor title': "Configure Trigger";
-            readonly 'trigger editor description': "Triggers are used to run functions at specific times or when specific events occur.";
-            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 'plugin.name': 'Automation';
+            readonly 'automation-panel.label': 'Automations';
+            readonly 'script-automation.label': 'Automation';
+            readonly 'automation-verbose.label': 'Manage automations';
+            readonly 'automation.description': 'Triggers that automate this space.';
+            readonly 'runtime.label': 'Trigger runtime location';
+            readonly 'runtime.description': 'Determines where the triggers in this space will execute.';
+            readonly 'runtime.disabled.label': 'Triggers disabled';
+            readonly 'runtime.local.label': 'Local';
+            readonly 'runtime.edge.label': 'EDGE (experimental)';
+            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': 'Functions deployed from this space on EDGE.';
+            readonly 'show-source-button.label': 'Show source';
+            readonly 'delete-function-button.label': 'Delete function';
+            readonly 'function-parameters.label': 'Function parameters';
+            readonly 'trigger-editor.title': 'Configure Trigger';
+            readonly 'trigger-editor.description': 'Triggers are used to run functions at specific times or when specific events occur.';
+            readonly 'new-trigger.label': 'Add Trigger';
+            readonly 'trigger-type.timer.label': 'Timer';
+            readonly 'trigger-type.webhook.label': 'Webhook';
+            readonly 'trigger-type.websocket.label': 'Websocket';
+            readonly 'trigger-type.subscription.label': 'Subscription';
+            readonly 'trigger-type.email.label': 'Email';
+            readonly 'trigger-type.feed.label': 'Feed';
+            readonly 'trigger-payload-prop-name.placeholder': 'New payload property name';
+            readonly 'import-function-button.label': 'Loading...';
+            readonly 'update-function-button.label': 'Update';
+            readonly 'loading-functions.message': 'Loading functions...';
+            readonly 'edge.trigger.status.loading.message': 'Loading edge trigger status\u2026';
+            readonly 'edge.trigger.status.unavailable.message': 'Edge trigger status unavailable';
+            readonly 'edge.trigger.status.dispatcher.label': 'Edge dispatcher: {{state}}';
+            readonly 'edge.trigger.status.active.label': 'active';
+            readonly 'edge.trigger.status.inactive.label': 'inactive';
+            readonly 'edge.trigger.status.next.cron.label': 'Next cron run: {{time}}';
+            readonly 'edge.trigger.status.next.alarm.label': 'Next alarm: {{time}}';
+            readonly 'edge.trigger.status.inactivity.label': 'Inactivity timeout: {{remaining}} remaining';
+            readonly 'edge.trigger.status.registered.label': 'Edge: registered';
+            readonly 'edge.trigger.status.not.registered.label': 'Edge: not registered';
+            readonly 'edge.trigger.status.registered.count.label': 'Enabled cron triggers on edge: {{registered}} / {{total}}';
+            readonly 'edge.trigger.status.cron.na.label': 'Edge: cron registration n/a';
+            readonly 'edge.trigger.status.disabled.detail.label': 'disabled';
         };
     };
 }];

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwCR;;EAGwB,CAAC"}
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/translations.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,YAAY;;;oCAIF,YAAY;+CACD,aAAa;gDACZ,YAAY;iDACX,oBAAoB;+CACtB,oCAAoC;sCAE7C,0BAA0B;4CACpB,2DAA2D;+CACxD,mBAAmB;4CACtB,OAAO;2CACR,qBAAqB;8CAElB,WAAW;gDACT,2BAA2B;yDAClB,oBAAoB;uDACtB,oCAAoC;8CAC7C,6CAA6C;iDAC1C,aAAa;qDACT,iBAAiB;kDAEpB,qBAAqB;6CAE1B,mBAAmB;mDAEzC,qFAAqF;0CAClE,aAAa;iDAEN,OAAO;mDACL,SAAS;qDACP,WAAW;wDACR,cAAc;iDACrB,OAAO;gDACR,MAAM;8DAEQ,2BAA2B;qDACpC,YAAY;qDACZ,QAAQ;kDACX,sBAAsB;4DAEZ,mCAA8B;gEAC1B,iCAAiC;6DACpC,4BAA4B;yDAChC,QAAQ;2DACN,UAAU;4DACT,yBAAyB;6DACxB,sBAAsB;6DACtB,6CAA6C;6DAC7C,kBAAkB;iEACd,sBAAsB;mEACpB,2DAA2D;0DACpE,6BAA6B;kEACrB,UAAU;;;EAIhC,CAAC"}

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

@@ -0,0 +1,21 @@
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Database } 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>;
+//# 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,MAAM,YAAY,CAAC;AAI3C,OAAO,EAAE,GAAG,IAAI,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAKtD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAI7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;4BAepC,CAAC"}

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

@@ -1,4 +1,3 @@
-export * from './capabilities';
-export * from './events';
 export * from './schema';
+export * as AutomationOperation from './AutomationOperation';
 //# 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,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AAEzB,OAAO,KAAK,mBAAmB,MAAM,uBAAuB,CAAC"}

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

@@ -1,9 +1,15 @@
 import * as Schema from 'effect/Schema';
-import { Capability } from '@dxos/app-framework';
 import { Database } from '@dxos/echo';
+export declare const TriggerTemplate: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["timer"]>;
+    cron: typeof Schema.String;
+}>, Schema.Struct<{
+    type: Schema.Literal<["feed"]>;
+    feed: typeof Schema.Any;
+}>]>;
 export declare namespace AutomationAction {
-    const CreateTriggerFromTemplate_base: Schema.TaggedClass<CreateTriggerFromTemplate, `${string}/action/create-trigger-from-template`, {
-        readonly _tag: Schema.tag<`${string}/action/create-trigger-from-template`>;
+    const CreateTriggerFromTemplate_base: Schema.TaggedClass<CreateTriggerFromTemplate, `${string}.action.create-trigger-from-template`, {
+        readonly _tag: Schema.tag<`${string}.action.create-trigger-from-template`>;
     } & {
         input: Schema.Struct<{
             db: Schema.Schema<Database.Database, Database.Database, never>;
@@ -11,8 +17,8 @@ export declare namespace AutomationAction {
                 type: Schema.Literal<["timer"]>;
                 cron: typeof Schema.String;
             }>, Schema.Struct<{
-                type: Schema.Literal<["queue"]>;
-                queueDXN: typeof Schema.Any;
+                type: Schema.Literal<["feed"]>;
+                feed: typeof Schema.Any;
             }>]>;
             enabled: Schema.optional<typeof Schema.Boolean>;
             scriptName: Schema.optional<typeof Schema.String>;
@@ -24,31 +30,4 @@ export declare namespace AutomationAction {
     }
     export {};
 }
-export declare namespace AutomationOperation {
-    const CreateTriggerFromTemplate: Omit<{
-        readonly meta: {
-            readonly key: `${string}/create-trigger-from-template`;
-            readonly name: "Create Trigger From Template";
-        };
-        readonly services: readonly [typeof Capability.Service];
-        readonly schema: {
-            readonly input: Schema.Struct<{
-                db: Schema.Schema<Database.Database, Database.Database, never>;
-                template: Schema.Union<[Schema.Struct<{
-                    type: Schema.Literal<["timer"]>;
-                    cron: typeof Schema.String;
-                }>, Schema.Struct<{
-                    type: Schema.Literal<["queue"]>;
-                    queueDXN: typeof Schema.Any;
-                }>]>;
-                enabled: Schema.optional<typeof Schema.Boolean>;
-                scriptName: Schema.optional<typeof Schema.String>;
-                input: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
-            }>;
-            readonly output: typeof Schema.Void;
-        };
-    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
-        readonly executionMode: "sync" | "async";
-    };
-}
 //# sourceMappingURL=schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAUtC,yBAAiB,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;IAChC,MAAM,OAAO,yBAA0B,SAAQ,8BAa9C;KAAG;;CACL;AAID,yBAAiB,mBAAmB,CAAC;IAC5B,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;KAapC,CAAC;CACJ"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC,eAAO,MAAM,eAAe;;;;;;IAG3B,CAAC;AAEF,yBAAiB,gBAAgB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;IACjC,MAAM,OAAO,yBAA0B,SAAQ,8BAa9C;KAAG;;CACL"}