@blue-labs/language 1.20.0

package/dist/repo/core/index.d.ts

@@ -0,0 +1,191 @@
+export * from './schema';
+export { blueIds } from './blue-ids';
+export declare const allSchemas: (import('zod').ZodObject<{
+    name: import('zod').ZodOptional<import('zod').ZodString>;
+    description: import('zod').ZodOptional<import('zod').ZodString>;
+}, "strip", import('zod').ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+}> | import('zod').ZodObject<import("zod").objectUtil.extendShape<{
+    name: import('zod').ZodOptional<import('zod').ZodString>;
+    description: import('zod').ZodOptional<import('zod').ZodString>;
+}, {
+    channels: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodString, "many">>;
+}>, "strip", import('zod').ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    channels?: string[] | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    channels?: string[] | undefined;
+}> | import('zod').ZodObject<import("zod").objectUtil.extendShape<{
+    name: import('zod').ZodOptional<import('zod').ZodString>;
+    description: import('zod').ZodOptional<import('zod').ZodString>;
+}, {
+    path: import('zod').ZodOptional<import('zod').ZodString>;
+}>, "strip", import('zod').ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+}> | import('zod').ZodObject<import("zod").objectUtil.extendShape<{
+    name: import('zod').ZodOptional<import('zod').ZodString>;
+    description: import('zod').ZodOptional<import('zod').ZodString>;
+}, {
+    path: import('zod').ZodOptional<import('zod').ZodString>;
+}>, "strip", import('zod').ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+}> | import('zod').ZodObject<{
+    request: import('zod').ZodOptional<import('zod').ZodType<import('../..').BlueNode, import('zod').ZodTypeDef, import('../..').BlueNode>>;
+    description: import('zod').ZodOptional<import('zod').ZodString>;
+    channel: import('zod').ZodOptional<import('zod').ZodString>;
+}, "strip", import('zod').ZodTypeAny, {
+    description?: string | undefined;
+    request?: import('../..').BlueNode | undefined;
+    channel?: string | undefined;
+}, {
+    description?: string | undefined;
+    request?: import('../..').BlueNode | undefined;
+    channel?: string | undefined;
+}> | import('zod').ZodObject<{
+    operation: import('zod').ZodOptional<import('zod').ZodString>;
+    request: import('zod').ZodType<import('../..').BlueNode, import('zod').ZodTypeDef, import('../..').BlueNode>;
+    document: import('zod').ZodOptional<import('zod').ZodObject<{
+        blueId: import('zod').ZodOptional<import('zod').ZodString>;
+    }, "strip", import('zod').ZodTypeAny, {
+        blueId?: string | undefined;
+    }, {
+        blueId?: string | undefined;
+    }>>;
+    allowNewerVersion: import('zod').ZodOptional<import('zod').ZodBoolean>;
+}, "strip", import('zod').ZodTypeAny, {
+    request: import('../..').BlueNode;
+    operation?: string | undefined;
+    document?: {
+        blueId?: string | undefined;
+    } | undefined;
+    allowNewerVersion?: boolean | undefined;
+}, {
+    request: import('../..').BlueNode;
+    operation?: string | undefined;
+    document?: {
+        blueId?: string | undefined;
+    } | undefined;
+    allowNewerVersion?: boolean | undefined;
+}> | import('zod').ZodObject<{
+    paths: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodString, "many">>;
+}, "strip", import('zod').ZodTypeAny, {
+    paths?: string[] | undefined;
+}, {
+    paths?: string[] | undefined;
+}> | import('zod').ZodObject<{
+    steps: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodType<import('../..').BlueNode, import('zod').ZodTypeDef, import('../..').BlueNode>, "many">>;
+    channel: import('zod').ZodOptional<import('zod').ZodString>;
+}, "strip", import('zod').ZodTypeAny, {
+    channel?: string | undefined;
+    steps?: import('../..').BlueNode[] | undefined;
+}, {
+    channel?: string | undefined;
+    steps?: import('../..').BlueNode[] | undefined;
+}> | import('zod').ZodObject<import("zod").objectUtil.extendShape<Omit<{
+    steps: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodType<import('../..').BlueNode, import('zod').ZodTypeDef, import('../..').BlueNode>, "many">>;
+    channel: import('zod').ZodOptional<import('zod').ZodString>;
+}, "channel">, {
+    operation: import('zod').ZodOptional<import('zod').ZodString>;
+}>, "strip", import('zod').ZodTypeAny, {
+    operation?: string | undefined;
+    steps?: import('../..').BlueNode[] | undefined;
+}, {
+    operation?: string | undefined;
+    steps?: import('../..').BlueNode[] | undefined;
+}> | import('zod').ZodObject<import("zod").objectUtil.extendShape<{
+    name: import('zod').ZodOptional<import('zod').ZodString>;
+    description: import('zod').ZodOptional<import('zod').ZodString>;
+}, {
+    timelineId: import('zod').ZodOptional<import('zod').ZodString>;
+}>, "strip", import('zod').ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    timelineId?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    timelineId?: string | undefined;
+}> | import('zod').ZodObject<{
+    timelineId: import('zod').ZodOptional<import('zod').ZodString>;
+    timelinePrev: import('zod').ZodOptional<import('zod').ZodString>;
+    thread: import('zod').ZodOptional<import('zod').ZodString>;
+    threadPrev: import('zod').ZodOptional<import('zod').ZodString>;
+    message: import('zod').ZodType<import('../..').BlueNode, import('zod').ZodTypeDef, import('../..').BlueNode>;
+    signature: import('zod').ZodOptional<import('zod').ZodString>;
+}, "strip", import('zod').ZodTypeAny, {
+    message: import('../..').BlueNode;
+    timelineId?: string | undefined;
+    timelinePrev?: string | undefined;
+    thread?: string | undefined;
+    threadPrev?: string | undefined;
+    signature?: string | undefined;
+}, {
+    message: import('../..').BlueNode;
+    timelineId?: string | undefined;
+    timelinePrev?: string | undefined;
+    thread?: string | undefined;
+    threadPrev?: string | undefined;
+    signature?: string | undefined;
+}> | import('zod').ZodObject<{
+    event: import('zod').ZodType<import('../..').BlueNode, import('zod').ZodTypeDef, import('../..').BlueNode>;
+}, "strip", import('zod').ZodTypeAny, {
+    event: import('../..').BlueNode;
+}, {
+    event: import('../..').BlueNode;
+}> | import('zod').ZodObject<{
+    changeset: import('zod').ZodArray<import('zod').ZodObject<{
+        name: import('zod').ZodOptional<import('zod').ZodString>;
+        description: import('zod').ZodOptional<import('zod').ZodString>;
+        val: import('zod').ZodOptional<import('zod').ZodType<import('../..').BlueNode, import('zod').ZodTypeDef, import('../..').BlueNode>>;
+        op: import('zod').ZodOptional<import('zod').ZodString>;
+        path: import('zod').ZodOptional<import('zod').ZodString>;
+    }, "strip", import('zod').ZodTypeAny, {
+        name?: string | undefined;
+        description?: string | undefined;
+        path?: string | undefined;
+        val?: import('../..').BlueNode | undefined;
+        op?: string | undefined;
+    }, {
+        name?: string | undefined;
+        description?: string | undefined;
+        path?: string | undefined;
+        val?: import('../..').BlueNode | undefined;
+        op?: string | undefined;
+    }>, "many">;
+}, "strip", import('zod').ZodTypeAny, {
+    changeset: {
+        name?: string | undefined;
+        description?: string | undefined;
+        path?: string | undefined;
+        val?: import('../..').BlueNode | undefined;
+        op?: string | undefined;
+    }[];
+}, {
+    changeset: {
+        name?: string | undefined;
+        description?: string | undefined;
+        path?: string | undefined;
+        val?: import('../..').BlueNode | undefined;
+        op?: string | undefined;
+    }[];
+}>)[];
+//# sourceMappingURL=index.d.ts.map

package/dist/repo/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/repo/core/index.ts"],"names":[],"mappings":"AAEA,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAyB,CAAC"}

package/dist/repo/core/schema/Channel.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const ChannelSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+}>;
+export type Channel = z.infer<typeof ChannelSchema>;
+//# sourceMappingURL=Channel.d.ts.map

package/dist/repo/core/schema/Channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Channel.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/Channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,aAAa;;;;;;;;;EAKzB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/repo/core/schema/CompositeTimelineChannel.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const CompositeTimelineChannelSchema: z.ZodObject<z.objectUtil.extendShape<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, {
+    channels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}>, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    channels?: string[] | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    channels?: string[] | undefined;
+}>;
+export type CompositeTimelineChannel = z.infer<typeof CompositeTimelineChannelSchema>;
+//# sourceMappingURL=CompositeTimelineChannel.d.ts.map

package/dist/repo/core/schema/CompositeTimelineChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositeTimelineChannel.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/CompositeTimelineChannel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;EAM1C,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC"}

package/dist/repo/core/schema/DocumentUpdateChannel.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const DocumentUpdateChannelSchema: z.ZodObject<z.objectUtil.extendShape<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, {
+    path: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+}>;
+export type DocumentUpdateChannel = z.infer<typeof DocumentUpdateChannelSchema>;
+//# sourceMappingURL=DocumentUpdateChannel.d.ts.map

package/dist/repo/core/schema/DocumentUpdateChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentUpdateChannel.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/DocumentUpdateChannel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;EAMvC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/repo/core/schema/EmbeddedNodeChannel.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const EmbeddedNodeChannelSchema: z.ZodObject<z.objectUtil.extendShape<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, {
+    path: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+}>;
+export type EmbeddedNodeChannel = z.infer<typeof EmbeddedNodeChannelSchema>;
+//# sourceMappingURL=EmbeddedNodeChannel.d.ts.map

package/dist/repo/core/schema/EmbeddedNodeChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedNodeChannel.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/EmbeddedNodeChannel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;EAMrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/repo/core/schema/JavaScriptCode.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const JavaScriptCodeSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code?: string | undefined;
+}, {
+    code?: string | undefined;
+}>;
+export type UpdateDocument = z.infer<typeof JavaScriptCodeSchema>;
+//# sourceMappingURL=JavaScriptCode.d.ts.map

package/dist/repo/core/schema/JavaScriptCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JavaScriptCode.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/JavaScriptCode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,oBAAoB;;;;;;EAIhC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/repo/core/schema/JsonPatchEntry.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const JsonPatchEntrySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    val: z.ZodOptional<z.ZodType<import('../../..').BlueNode, z.ZodTypeDef, import('../../..').BlueNode>>;
+    op: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+    val?: import('../../..').BlueNode | undefined;
+    op?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    path?: string | undefined;
+    val?: import('../../..').BlueNode | undefined;
+    op?: string | undefined;
+}>;
+export type JsonPatchEntry = z.infer<typeof JsonPatchEntrySchema>;
+//# sourceMappingURL=JsonPatchEntry.d.ts.map

package/dist/repo/core/schema/JsonPatchEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonPatchEntry.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/JsonPatchEntry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAQhC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/repo/core/schema/Operation.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const OperationSchema: z.ZodObject<{
+    request: z.ZodOptional<z.ZodType<import('../../..').BlueNode, z.ZodTypeDef, import('../../..').BlueNode>>;
+    description: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    description?: string | undefined;
+    request?: import('../../..').BlueNode | undefined;
+    channel?: string | undefined;
+}, {
+    description?: string | undefined;
+    request?: import('../../..').BlueNode | undefined;
+    channel?: string | undefined;
+}>;
+export type Operation = z.infer<typeof OperationSchema>;
+//# sourceMappingURL=Operation.d.ts.map

package/dist/repo/core/schema/Operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Operation.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/Operation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,eAAe;;;;;;;;;;;;EAM3B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/repo/core/schema/OperationRequest.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const OperationRequestSchema: z.ZodObject<{
+    operation: z.ZodOptional<z.ZodString>;
+    request: z.ZodType<import('../../..').BlueNode, z.ZodTypeDef, import('../../..').BlueNode>;
+    document: z.ZodOptional<z.ZodObject<{
+        blueId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        blueId?: string | undefined;
+    }, {
+        blueId?: string | undefined;
+    }>>;
+    allowNewerVersion: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    request: import('../../..').BlueNode;
+    operation?: string | undefined;
+    document?: {
+        blueId?: string | undefined;
+    } | undefined;
+    allowNewerVersion?: boolean | undefined;
+}, {
+    request: import('../../..').BlueNode;
+    operation?: string | undefined;
+    document?: {
+        blueId?: string | undefined;
+    } | undefined;
+    allowNewerVersion?: boolean | undefined;
+}>;
+export type OperationRequest = z.infer<typeof OperationRequestSchema>;
+//# sourceMappingURL=OperationRequest.d.ts.map

package/dist/repo/core/schema/OperationRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationRequest.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/OperationRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;EAalC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/repo/core/schema/ProcessEmbedded.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const ProcessEmbeddedSchema: z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    paths?: string[] | undefined;
+}, {
+    paths?: string[] | undefined;
+}>;
+export type ProcessEmbedded = z.infer<typeof ProcessEmbeddedSchema>;
+//# sourceMappingURL=ProcessEmbedded.d.ts.map

package/dist/repo/core/schema/ProcessEmbedded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessEmbedded.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/ProcessEmbedded.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,qBAAqB;;;;;;EAMjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/repo/core/schema/SequentialWorkflow.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const SequentialWorkflowSchema: z.ZodObject<{
+    steps: z.ZodOptional<z.ZodArray<z.ZodType<import('../../..').BlueNode, z.ZodTypeDef, import('../../..').BlueNode>, "many">>;
+    channel: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    channel?: string | undefined;
+    steps?: import('../../..').BlueNode[] | undefined;
+}, {
+    channel?: string | undefined;
+    steps?: import('../../..').BlueNode[] | undefined;
+}>;
+export type SequentialWorkflow = z.infer<typeof SequentialWorkflowSchema>;
+//# sourceMappingURL=SequentialWorkflow.d.ts.map

package/dist/repo/core/schema/SequentialWorkflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SequentialWorkflow.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/SequentialWorkflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,wBAAwB;;;;;;;;;EAOpC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/repo/core/schema/SequentialWorkflowOperation.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const SequentialWorkflowOperationSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
+    steps: z.ZodOptional<z.ZodArray<z.ZodType<import('../../..').BlueNode, z.ZodTypeDef, import('../../..').BlueNode>, "many">>;
+    channel: z.ZodOptional<z.ZodString>;
+}, "channel">, {
+    operation: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    operation?: string | undefined;
+    steps?: import('../../..').BlueNode[] | undefined;
+}, {
+    operation?: string | undefined;
+    steps?: import('../../..').BlueNode[] | undefined;
+}>;
+export type SequentialWorkflowOperation = z.infer<typeof SequentialWorkflowOperationSchema>;
+//# sourceMappingURL=SequentialWorkflowOperation.d.ts.map

package/dist/repo/core/schema/SequentialWorkflowOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SequentialWorkflowOperation.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/SequentialWorkflowOperation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,iCAAiC;;;;;;;;;;;EAQ7C,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC"}

package/dist/repo/core/schema/SequentialWorkflowStep.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const SequentialWorkflowStepSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+}>;
+export type SequentialWorkflowStep = z.infer<typeof SequentialWorkflowStepSchema>;
+//# sourceMappingURL=SequentialWorkflowStep.d.ts.map

package/dist/repo/core/schema/SequentialWorkflowStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SequentialWorkflowStep.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/SequentialWorkflowStep.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,4BAA4B;;;;;;;;;EAOxC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC"}

package/dist/repo/core/schema/TimelineChannel.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const TimelineChannelSchema: z.ZodObject<z.objectUtil.extendShape<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, {
+    timelineId: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    description?: string | undefined;
+    timelineId?: string | undefined;
+}, {
+    name?: string | undefined;
+    description?: string | undefined;
+    timelineId?: string | undefined;
+}>;
+export type TimelineChannel = z.infer<typeof TimelineChannelSchema>;
+//# sourceMappingURL=TimelineChannel.d.ts.map

package/dist/repo/core/schema/TimelineChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimelineChannel.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/TimelineChannel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;EAMjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/repo/core/schema/TimelineEntry.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const TimelineEntrySchema: z.ZodObject<{
+    timelineId: z.ZodOptional<z.ZodString>;
+    timelinePrev: z.ZodOptional<z.ZodString>;
+    thread: z.ZodOptional<z.ZodString>;
+    threadPrev: z.ZodOptional<z.ZodString>;
+    message: z.ZodType<import('../../..').BlueNode, z.ZodTypeDef, import('../../..').BlueNode>;
+    signature: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: import('../../..').BlueNode;
+    timelineId?: string | undefined;
+    timelinePrev?: string | undefined;
+    thread?: string | undefined;
+    threadPrev?: string | undefined;
+    signature?: string | undefined;
+}, {
+    message: import('../../..').BlueNode;
+    timelineId?: string | undefined;
+    timelinePrev?: string | undefined;
+    thread?: string | undefined;
+    threadPrev?: string | undefined;
+    signature?: string | undefined;
+}>;
+export type TimelineEntry = z.infer<typeof TimelineEntrySchema>;
+//# sourceMappingURL=TimelineEntry.d.ts.map

package/dist/repo/core/schema/TimelineEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimelineEntry.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/TimelineEntry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAS/B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/repo/core/schema/TriggerEvent.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const TriggerEventSchema: z.ZodObject<{
+    event: z.ZodType<import('../../..').BlueNode, z.ZodTypeDef, import('../../..').BlueNode>;
+}, "strip", z.ZodTypeAny, {
+    event: import('../../..').BlueNode;
+}, {
+    event: import('../../..').BlueNode;
+}>;
+export type TriggerEvent = z.infer<typeof TriggerEventSchema>;
+//# sourceMappingURL=TriggerEvent.d.ts.map

package/dist/repo/core/schema/TriggerEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TriggerEvent.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/TriggerEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,kBAAkB;;;;;;EAI9B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/repo/core/schema/UpdateDocument.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const UpdateDocumentSchema: z.ZodObject<{
+    changeset: z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        val: z.ZodOptional<z.ZodType<import('../../..').BlueNode, z.ZodTypeDef, import('../../..').BlueNode>>;
+        op: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | undefined;
+        description?: string | undefined;
+        path?: string | undefined;
+        val?: import('../../..').BlueNode | undefined;
+        op?: string | undefined;
+    }, {
+        name?: string | undefined;
+        description?: string | undefined;
+        path?: string | undefined;
+        val?: import('../../..').BlueNode | undefined;
+        op?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    changeset: {
+        name?: string | undefined;
+        description?: string | undefined;
+        path?: string | undefined;
+        val?: import('../../..').BlueNode | undefined;
+        op?: string | undefined;
+    }[];
+}, {
+    changeset: {
+        name?: string | undefined;
+        description?: string | undefined;
+        path?: string | undefined;
+        val?: import('../../..').BlueNode | undefined;
+        op?: string | undefined;
+    }[];
+}>;
+export type UpdateDocument = z.infer<typeof UpdateDocumentSchema>;
+//# sourceMappingURL=UpdateDocument.d.ts.map

package/dist/repo/core/schema/UpdateDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateDocument.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/UpdateDocument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/repo/core/schema/index.d.ts

@@ -0,0 +1,14 @@
+export * from './Channel';
+export * from './CompositeTimelineChannel';
+export * from './DocumentUpdateChannel';
+export * from './EmbeddedNodeChannel';
+export * from './Operation';
+export * from './OperationRequest';
+export * from './ProcessEmbedded';
+export * from './SequentialWorkflow';
+export * from './SequentialWorkflowOperation';
+export * from './TimelineChannel';
+export * from './TimelineEntry';
+export * from './TriggerEvent';
+export * from './UpdateDocument';
+//# sourceMappingURL=index.d.ts.map

package/dist/repo/core/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/repo/core/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}

package/dist/repo/myos/blue-ids/index.d.ts

@@ -0,0 +1,8 @@
+export declare const blueIds: {
+    readonly 'MyOS Timeline Channel': "MkKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc2R";
+    readonly 'MyOS Timeline Entry': "uDxZ7dr6Eo2MkKoutP5qxkh3uxQCS1VAptiCPc2R7B7f";
+    readonly 'MyOS Agent': "AgentBlu3Id7dr6Eo2MkKoutP5qxkh3uxQCS1V";
+    readonly 'MyOS Agent Channel': "AgentCh4nn3lBlu3Id7dr6Eo2MkKoutP5qxkh3uxQCS1V";
+    readonly 'MyOS Agent Event': "AgentEv3ntBlu3Id7dr6Eo2MkKoutP5qxkh3uxQCS1V";
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/repo/myos/blue-ids/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/repo/myos/blue-ids/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO;;;;;;CAMV,CAAC"}