@dxos/plugin-observability 0.8.4-main.72ec0f3 → 0.8.4-main.8360d9e660

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

@@ -0,0 +1,3 @@
+export { ObservabilitySettings, ObservabilitySettingsSchema, type ObservabilitySettingsProps, type ObservabilitySettingsComponentProps, } from './ObservabilitySettings';
+export { ObservabilitySettings as default } from './ObservabilitySettings';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/containers/ObservabilitySettings/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,qBAAqB,EACrB,2BAA2B,EAC3B,KAAK,0BAA0B,EAC/B,KAAK,mCAAmC,GACzC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,qBAAqB,IAAI,OAAO,EAAE,MAAM,yBAAyB,CAAC"}

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

@@ -0,0 +1,6 @@
+import { type ComponentType } from 'react';
+export { ObservabilitySettingsSchema } from './ObservabilitySettings';
+export type { ObservabilitySettingsProps, ObservabilitySettingsComponentProps } from './ObservabilitySettings';
+export declare const HelpContainer: ComponentType<any>;
+export declare const ObservabilitySettings: ComponentType<any>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/containers/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,aAAa,EAAQ,MAAM,OAAO,CAAC;AAEjD,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,YAAY,EAAE,0BAA0B,EAAE,mCAAmC,EAAE,MAAM,yBAAyB,CAAC;AAE/G,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,GAAG,CAAyC,CAAC;AACvF,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,GAAG,CAAiD,CAAC"}

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

@@ -1,5 +1,4 @@
-export { ObservabilityCapabilities } from './capabilities';
-export { ObservabilityEvents } from './events';
+export { ObservabilityCapabilities, ObservabilityEvents } from './types';
 export * from './components';
 export * from './meta';
 export * from './ObservabilityPlugin';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC/C,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACzE,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,uBAAuB,CAAC"}

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

@@ -1,3 +1,3 @@
-import { type PluginMeta } from '@dxos/app-framework';
-export declare const meta: PluginMeta;
+import { type Plugin } from '@dxos/app-framework';
+export declare const meta: Plugin.Meta;
 //# sourceMappingURL=meta.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../../src/meta.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtD,eAAO,MAAM,IAAI,EAAE,UAQlB,CAAC"}
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../../src/meta.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,IAQzB,CAAC"}

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

@@ -12,8 +12,9 @@ export declare const translations: [{
             readonly 'observability enabled label': "Enable telemetry";
             readonly 'observability description': "When enabled, basic usage data will used to improve the product. This may include performance metrics, error logs, and usage data. No personally identifiable information, other than your public key, is included with this data and no private data ever leaves your devices.";
             readonly 'help label': "Feedback & Support";
-            readonly 'feedback text area label': "Feedback";
-            readonly 'feedback text area placeholder': "Please enter your feedback, technical issue, or feature request.";
+            readonly 'feedback textarea label': "Feedback";
+            readonly 'feedback textarea placeholder': "Please enter your feedback, technical issue, or feature request.";
+            readonly 'include debug logs label': "Include debug logs";
             readonly 'send feedback label': "Send Feedback";
             readonly 'feedback toast label': "Thank you for your feedback!";
             readonly 'feedback toast description': "We will review your feedback and get back to you as soon as possible.";

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;;;;;;;;;;;;;;;;UAoBR;;EAGwB,CAAC"}
+{"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;;;;;;;;;;;;;;;;;UAoBR;;EAGwB,CAAC"}

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

@@ -0,0 +1,27 @@
+import { type Atom } from '@effect-atom/atom-react';
+import * as Schema from 'effect/Schema';
+import { Capability } from '@dxos/app-framework';
+import { type Client } from '@dxos/client';
+import { type Observability } from '@dxos/observability';
+export declare namespace ObservabilityCapabilities {
+    const Settings: Capability.InterfaceDef<Atom.Writable<{
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>;
+    const StateSchema: Schema.mutable<Schema.Struct<{
+        group: Schema.optional<typeof Schema.String>;
+        notified: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    type State = Schema.Schema.Type<typeof StateSchema>;
+    const State: Capability.InterfaceDef<Atom.Writable<{
+        group?: string | undefined;
+        notified?: boolean | undefined;
+    }, {
+        group?: string | undefined;
+        notified?: boolean | undefined;
+    }>>;
+    const Observability: Capability.InterfaceDef<Observability.Observability>;
+}
+export declare const ClientCapability: Capability.InterfaceDef<Client>;
+//# sourceMappingURL=capabilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../src/types/capabilities.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKzD,yBAAiB,yBAAyB,CAAC;IAClC,MAAM,QAAQ;;;;OAA+F,CAAC;IAE9G,MAAM,WAAW;;;OAKvB,CAAC;IAEF,KAAY,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC,CAAC;IAEpD,MAAM,KAAK;;;;;;OAAuE,CAAC;IAEnF,MAAM,aAAa,sDAAsF,CAAC;CAClH;AAID,eAAO,MAAM,gBAAgB,iCAAsE,CAAC"}

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

@@ -0,0 +1,6 @@
+import { ActivationEvent } from '@dxos/app-framework';
+export declare namespace ObservabilityEvents {
+    const StateReady: ActivationEvent.ActivationEvent;
+}
+export declare const ClientReadyEvent: ActivationEvent.ActivationEvent;
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../src/types/events.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKtD,yBAAiB,mBAAmB,CAAC;IAC5B,MAAM,UAAU,EAAE,eAAe,CAAC,eAA+D,CAAC;CAC1G;AAGD,eAAO,MAAM,gBAAgB,iCAAoE,CAAC"}

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

@@ -1,2 +1,4 @@
+export * from './capabilities';
+export * from './events';
 export * from './schema';
 //# 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,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

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

@@ -1,313 +1,63 @@
 import * as Schema from 'effect/Schema';
-import { Type } 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>>;
+    includeLogs: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
 }>;
 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<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.join"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.limit"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.lock"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.migrate"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.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<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                typename: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.schema.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                objectId: typeof Schema.String;
-                typename: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.object.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                objectId: typeof Schema.String;
-                typename: Schema.optional<typeof Schema.String>;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.share"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["space.unlock"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.create"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.add"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.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<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                messageId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.undo-delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-                messageId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.message.update"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                messageId: typeof Schema.String;
-                messageLength: typeof Schema.Number;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.toggle-resolved"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.SpaceId;
-                };
-                threadId: typeof Schema.String;
-            }>;
-        }>, Schema.Struct<{
-            name: Schema.Literal<["threads.undo-delete"]>;
-            properties: Schema.Struct<{
-                spaceId: Schema.Schema<Type.SpaceId, string, never> & {
-                    byteLength: number;
-                    encode: (value: Uint8Array) => Type.SpaceId;
-                    decode: (value: Type.SpaceId) => Uint8Array;
-                    isValid: (value: string) => value is Type.SpaceId;
-                    make: (value: string) => Type.SpaceId;
-                    random: () => Type.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>>;
+                includeLogs: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+            }>;
+            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,IAAI,EAAE,MAAM,YAAY,CAAC;AAUlC,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;;;EAevB,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"}