@dxos/plugin-observability 0.8.4-main.7ace549 → 0.8.4-main.937b3ca

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

@@ -1,313 +1,61 @@
 import * as Schema from 'effect/Schema';
-import { Key } from '@dxos/echo';
+import { Capability } from '@dxos/app-framework';
 export declare const UserFeedback: Schema.Struct<{
-    message: Schema.filter<Schema.filter<typeof Schema.String>>;
+    message: Schema.refine<string, Schema.filter<typeof Schema.String>>;
 }>;
 export type UserFeedback = Schema.Schema.Type<typeof UserFeedback>;
-export declare namespace ObservabilityAction {
-    const Toggle_base: Schema.TaggedClass<Toggle, `${string}/action/toggle`, {
-        readonly _tag: Schema.tag<`${string}/action/toggle`>;
-    } & {
-        input: Schema.Struct<{
-            state: Schema.optional<typeof Schema.Boolean>;
-        }>;
-        output: typeof Schema.Boolean;
-    }>;
-    export class Toggle extends Toggle_base {
-    }
-    const CaptureUserFeedback_base: Schema.TaggedClass<CaptureUserFeedback, `${string}/action/capture-feedback`, {
-        readonly _tag: Schema.tag<`${string}/action/capture-feedback`>;
-    } & {
-        input: Schema.Struct<{
-            message: Schema.filter<Schema.filter<typeof Schema.String>>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class CaptureUserFeedback extends CaptureUserFeedback_base {
-    }
-    const BaseSendEvent_base: Schema.TaggedClass<BaseSendEvent, `${string}/action/send-event`, {
-        readonly _tag: Schema.tag<`${string}/action/send-event`>;
-    } & {
-        input: Schema.Struct<{
-            name: typeof Schema.String;
-            properties: Schema.optional<typeof Schema.Object>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    /** Base intent for sending events. */
-    export class BaseSendEvent extends BaseSendEvent_base {
-    }
-    const SendEvent_base: Schema.TaggedClass<SendEvent, `${string}/action/send-event`, {
-        readonly _tag: Schema.tag<`${string}/action/send-event`>;
-    } & {
-        input: Schema.Union<[Schema.Struct<{
-            name: Schema.Literal<["identity.create"]>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["identity.join"]>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["identity.recover"]>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["identity.share"]>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["navigation.activate"]>;
-            properties: Schema.Struct<{
-                subjectId: typeof Schema.String;
-                typename: Schema.optional<typeof Schema.String>;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["page.load"]>;
-            properties: Schema.Struct<{
-                loadDuration: typeof Schema.Number;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["plugins.toggle"]>;
-            properties: Schema.Struct<{
-                plugin: typeof Schema.String;
-                enabled: typeof Schema.Boolean;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.create"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.join"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.limit"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.lock"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.migrate"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                targetVersion: Schema.optional<typeof Schema.String>;
-                version: Schema.optional<typeof Schema.String>;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.schema.use"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                typename: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.schema.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                objectId: typeof Schema.String;
-                typename: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.object.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                objectId: typeof Schema.String;
-                typename: Schema.optional<typeof Schema.String>;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.share"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.unlock"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.create"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                threadLength: typeof Schema.Number;
-                messageId: typeof Schema.String;
-                messageLength: typeof Schema.Number;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                messageId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.undo-delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                messageId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.update"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                messageId: typeof Schema.String;
-                messageLength: typeof Schema.Number;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.toggle-resolved"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.undo-delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Key.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Key.SpaceId;
-                    decode: (value: Key.SpaceId) => Uint8Array;
-                    isValid: (value: unknown) => value is Key.SpaceId;
-                    make: (value: string) => Key.SpaceId;
-                    random: () => Key.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>]>;
-        output: typeof Schema.Void;
-    }>;
-    /** Intent with strict types for first-party events. */
-    export class SendEvent extends SendEvent_base {
-    }
-    export {};
+/**
+ * Operations for the Observability plugin.
+ */
+export declare namespace ObservabilityOperation {
+    const Toggle: Omit<{
+        readonly meta: {
+            readonly key: `${string}/toggle`;
+            readonly name: "Toggle Observability";
+            readonly description: "Toggle observability on or off.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                state: Schema.optional<typeof Schema.Boolean>;
+            }>;
+            readonly output: typeof Schema.Boolean;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const CaptureUserFeedback: Omit<{
+        readonly meta: {
+            readonly key: `${string}/capture-feedback`;
+            readonly name: "Capture User Feedback";
+            readonly description: "Capture user feedback.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                message: Schema.refine<string, Schema.filter<typeof Schema.String>>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const SendEvent: Omit<{
+        readonly meta: {
+            readonly key: `${string}/send-event`;
+            readonly name: "Send Event";
+            readonly description: "Send an observability event.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                name: Schema.SchemaClass<string, string, never>;
+                properties: Schema.optional<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,GAAG,EAAE,MAAM,YAAY,CAAC;AAUjC,eAAO,MAAM,YAAY;;EAEvB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC;AAEnE,yBAAiB,mBAAmB,CAAC;;;;;;;;;IACnC,MAAM,OAAO,MAAO,SAAQ,WAK1B;KAAG;;;;;;;;;IAEL,MAAM,OAAO,mBAAoB,SAAQ,wBAMxC;KAAG;;;;;;;;;;IAEJ,sCAAsC;IACtC,MAAM,OAAO,aAAc,SAAQ,kBAMjC;KAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEL,uDAAuD;IACvD,MAAM,OAAO,SAAU,SAAQ,cAsK7B;KAAG;;CACN"}
+{"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;AASjD,eAAO,MAAM,YAAY;;EASvB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC;AAInE;;GAEG;AACH,yBAAiB,sBAAsB,CAAC;IAC/B,MAAM,MAAM;;;;;;;;;;;;;;;KAajB,CAAC;IAEI,MAAM,mBAAmB;;;;;;;;;;;;;;;KAW9B,CAAC;IAEI,MAAM,SAAS;;;;;;;;;;;;;;;;KAcpB,CAAC;CACJ"}