@dxos/plugin-space 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

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

@@ -1,14 +1,34 @@
+import type * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
-import { type AnyIntentChain } from '@dxos/app-framework';
-import { type Obj, Type } from '@dxos/echo';
-import { type BaseObject, EchoSchema } from '@dxos/echo/internal';
-import { type PublicKey } from '@dxos/react-client';
-import { type Space } from '@dxos/react-client/echo';
-import { CancellableInvitationObservable, Invitation } from '@dxos/react-client/invitations';
-import { DataType } from '@dxos/schema';
+import { Capability, Plugin } from '@dxos/app-framework';
+import { type PublicKey } from '@dxos/client';
+import { CancellableInvitationObservable, Invitation } from '@dxos/client/invitations';
+import { Database, Obj, QueryAST, Type } from '@dxos/echo';
+import { View } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
 import { type ComplexMap } from '@dxos/util';
 export declare const SPACE_DIRECTORY_HANDLE: string;
 export declare const SPACE_TYPE = "dxos.org/type/Space";
+export type SpacePluginOptions = {
+    /**
+     * Origin used for shareable links (object copy-link and invitation base).
+     * Defaults to window.location.origin.
+     */
+    shareableLinkOrigin?: string;
+    /**
+     * Path appended to shareableLinkOrigin to form the invitation base URL.
+     * Defaults to '/'.
+     */
+    invitationPath?: string;
+    /**
+     * Query parameter name for the invitation code.
+     */
+    invitationProp?: string;
+    /**
+     * Whether to send observability events.
+     */
+    observability?: boolean;
+};
 export type ObjectViewerProps = {
     lastSeen: number;
     currentlyAttended: boolean;
@@ -53,7 +73,7 @@ export declare const SpaceSettingsSchema: Schema.mutable<Schema.Struct<{
 }>>;
 export type SpaceSettingsProps = Schema.Schema.Type<typeof SpaceSettingsSchema>;
 export type SerializerMap = Record<string, TypedObjectSerializer>;
-export interface TypedObjectSerializer<T extends Obj.Any = Type.Expando> {
+export interface TypedObjectSerializer<T extends Obj.Unknown = Obj.Unknown> {
     serialize(params: {
         object: T;
     }): Promise<string>;
@@ -64,417 +84,595 @@ export interface TypedObjectSerializer<T extends Obj.Any = Type.Expando> {
      */
     deserialize(params: {
         content: string;
-        space: Space;
+        db: Database.Database;
         newId?: boolean;
     }): Promise<T>;
 }
+/**
+ * Factory function that creates an object directly using Type.make().
+ * Returns an Effect that resolves to the created object.
+ *
+ * Options include:
+ * - `db`: The database to use for object creation.
+ */
+export type CreateObject = (props: any, options: {
+    db: Database.Database;
+}) => Effect.Effect<Obj.Unknown, Error, Capability.Service | Operation.Service>;
 export declare const IconAnnotationId: unique symbol;
 export declare const HueAnnotationId: unique symbol;
 export declare const SpaceForm: Schema.Struct<{
     name: Schema.optional<Schema.SchemaClass<string, string, never>>;
     icon: Schema.optional<Schema.SchemaClass<string, string, never>>;
     hue: Schema.optional<Schema.SchemaClass<string, string, never>>;
-    edgeReplication: Schema.SchemaClass<boolean, boolean, never>;
+    edgeReplication: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
 }>;
-export type ObjectForm<T extends BaseObject = BaseObject> = {
-    objectSchema: Schema.Schema.AnyNoContext;
-    formSchema?: Schema.Schema<T, any>;
-    hidden?: boolean;
-    getIntent: (props: T, options: {
-        space: Space;
-    }) => AnyIntentChain;
-};
-export declare const defineObjectForm: <T extends BaseObject>(form: ObjectForm<T>) => ObjectForm<T>;
-export declare const SPACE_ACTION: string;
-export declare namespace SpaceAction {
-    const OpenCreateSpace_base: Schema.TaggedClass<OpenCreateSpace, `${string}/open-create-space`, {
-        readonly _tag: Schema.tag<`${string}/open-create-space`>;
-    } & {
-        input: typeof Schema.Void;
-        output: typeof Schema.Void;
+export declare namespace CollectionOperation {
+    const Create: Omit<{
+        readonly meta: {
+            readonly key: "dxos.org/plugin/collection/operation/create";
+            readonly name: "Create Collection";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                name: Schema.optional<typeof Schema.String>;
+            }>;
+            readonly output: Schema.Struct<{
+                object: Type.Obj<{
+                    readonly name?: string | undefined;
+                    readonly objects: readonly import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+                }, Schema.Struct.Fields>;
+            }>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+}
+/**
+ * Operations for the Space plugin.
+ */
+export declare namespace SpaceOperation {
+    const Create: Omit<{
+        readonly meta: {
+            readonly key: `${string}/create`;
+            readonly name: "Create Space";
+            readonly description: "Create a new space.";
+        };
+        readonly services: readonly [typeof Capability.Service, typeof Plugin.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                name: Schema.optional<Schema.SchemaClass<string, string, never>>;
+                icon: Schema.optional<Schema.SchemaClass<string, string, never>>;
+                hue: Schema.optional<Schema.SchemaClass<string, string, never>>;
+                edgeReplication: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+            }>;
+            readonly output: Schema.Struct<{
+                id: typeof Schema.String;
+                subject: Schema.Array$<typeof Schema.String>;
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+            }>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const Join: Omit<{
+        readonly meta: {
+            readonly key: `${string}/join`;
+            readonly name: "Join Space";
+            readonly description: "Join a space via invitation.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                invitationCode: Schema.optional<typeof Schema.String>;
+                onDone: Schema.optional<typeof Schema.Any>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const Open: Omit<{
+        readonly meta: {
+            readonly key: `${string}/open`;
+            readonly name: "Open Space";
+            readonly description: "Open a space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const Close: Omit<{
+        readonly meta: {
+            readonly key: `${string}/close`;
+            readonly name: "Close Space";
+            readonly description: "Close a space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const Share: Omit<{
+        readonly meta: {
+            readonly key: `${string}/share`;
+            readonly name: "Share Space";
+            readonly description: "Share a space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+                type: Schema.Enums<typeof Invitation.Type>;
+                authMethod: Schema.Enums<typeof Invitation.AuthMethod>;
+                multiUse: typeof Schema.Boolean;
+                target: Schema.optional<typeof Schema.String>;
+            }>;
+            readonly output: Schema.instanceOf<CancellableInvitationObservable>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const Lock: Omit<{
+        readonly meta: {
+            readonly key: `${string}/lock`;
+            readonly name: "Lock Space";
+            readonly description: "Lock a space to prevent modifications.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const Unlock: Omit<{
+        readonly meta: {
+            readonly key: `${string}/unlock`;
+            readonly name: "Unlock Space";
+            readonly description: "Unlock a space to allow modifications.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const OpenSettings: Omit<{
+        readonly meta: {
+            readonly key: `${string}/open-settings`;
+            readonly name: "Open Space Settings";
+            readonly description: "Open space settings.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const WaitForObject: Omit<{
+        readonly meta: {
+            readonly key: `${string}/wait-for-object`;
+            readonly name: "Wait For Object";
+            readonly description: "Wait for an object to be available.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                id: Schema.optional<typeof Schema.String>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const AddObject: Omit<{
+        readonly meta: {
+            readonly key: `${string}/add-object`;
+            readonly name: "Add Object";
+            readonly description: "Add an object to a space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                object: Type.Obj<Obj.Unknown, Schema.Struct.Fields>;
+                target: Schema.Union<[Schema.Schema<Database.Database, Database.Database, never>, Type.Obj<{
+                    readonly name?: string | undefined;
+                    readonly objects: readonly import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+                }, Schema.Struct.Fields>]>;
+                hidden: Schema.optional<typeof Schema.Boolean>;
+            }>;
+            readonly output: Schema.Struct<{
+                id: typeof Schema.String;
+                subject: Schema.Array$<typeof Schema.String>;
+                object: Type.Obj<Obj.Unknown, Schema.Struct.Fields>;
+            }>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const RemoveObjectsOutput: Schema.Struct<{
+        objects: Schema.Array$<Type.Obj<Obj.Unknown, Schema.Struct.Fields>>;
+        parentCollection: Type.Obj<{
+            readonly name?: string | undefined;
+            readonly objects: readonly import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+        }, Schema.Struct.Fields>;
+        indices: Schema.Array$<typeof Schema.Number>;
+        nestedObjectsList: Schema.Array$<Schema.Array$<Type.Obj<Obj.Unknown, Schema.Struct.Fields>>>;
+        wasActive: Schema.Array$<typeof Schema.String>;
     }>;
-    export class OpenCreateSpace extends OpenCreateSpace_base {
-    }
-    const Create_base: Schema.TaggedClass<Create, `${string}/create`, {
-        readonly _tag: Schema.tag<`${string}/create`>;
-    } & {
-        input: Schema.Struct<{
-            name: Schema.optional<Schema.SchemaClass<string, string, never>>;
-            icon: Schema.optional<Schema.SchemaClass<string, string, never>>;
-            hue: Schema.optional<Schema.SchemaClass<string, string, never>>;
-            edgeReplication: Schema.SchemaClass<boolean, boolean, never>;
-        }>;
-        output: Schema.Struct<{
+    type RemoveObjectsOutput = Schema.Schema.Type<typeof RemoveObjectsOutput>;
+    const RemoveObjects: Omit<{
+        readonly meta: {
+            readonly key: `${string}/remove-objects`;
+            readonly name: "Remove Objects";
+            readonly description: "Remove objects from a space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                objects: Schema.Array$<Type.Obj<Obj.Unknown, Schema.Struct.Fields>>;
+                target: Schema.optional<Type.Obj<{
+                    readonly name?: string | undefined;
+                    readonly objects: readonly import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+                }, Schema.Struct.Fields>>;
+            }>;
+            readonly output: Schema.Struct<{
+                objects: Schema.Array$<Type.Obj<Obj.Unknown, Schema.Struct.Fields>>;
+                parentCollection: Type.Obj<{
+                    readonly name?: string | undefined;
+                    readonly objects: readonly import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+                }, Schema.Struct.Fields>;
+                indices: Schema.Array$<typeof Schema.Number>;
+                nestedObjectsList: Schema.Array$<Schema.Array$<Type.Obj<Obj.Unknown, Schema.Struct.Fields>>>;
+                wasActive: Schema.Array$<typeof Schema.String>;
+            }>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const DeleteFieldOutput: Schema.Struct<{
+        field: Schema.Struct<{
             id: typeof Schema.String;
-            subject: Schema.Array$<typeof Schema.String>;
-            space: Schema.Schema<Space, Space, never>;
-        }>;
-    }>;
-    export class Create extends Create_base {
-    }
-    const Join_base: Schema.TaggedClass<Join, `${string}/join`, {
-        readonly _tag: Schema.tag<`${string}/join`>;
-    } & {
-        input: Schema.Struct<{
-            invitationCode: Schema.optional<typeof Schema.String>;
-            onDone: Schema.optional<typeof Schema.Any>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class Join extends Join_base {
-    }
-    const OpenMembers_base: Schema.TaggedClass<OpenMembers, `${string}/open-members`, {
-        readonly _tag: Schema.tag<`${string}/open-members`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class OpenMembers extends OpenMembers_base {
-    }
-    const Share_base: Schema.TaggedClass<Share, `${string}/share`, {
-        readonly _tag: Schema.tag<`${string}/share`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-            type: Schema.Enums<typeof Invitation.Type>;
-            authMethod: Schema.Enums<typeof Invitation.AuthMethod>;
-            multiUse: typeof Schema.Boolean;
-            target: Schema.optional<typeof Schema.String>;
+            path: Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>;
+            visible: Schema.optional<typeof Schema.Boolean>;
+            referencePath: Schema.optional<Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>>;
         }>;
-        output: Schema.instanceOf<CancellableInvitationObservable>;
+        props: Schema.SchemaClass<any, any, never>;
+        index: Schema.SchemaClass<number, number, never>;
     }>;
-    export class Share extends Share_base {
-    }
-    const GetShareLink_base: Schema.TaggedClass<GetShareLink, `${string}/get-share-link`, {
-        readonly _tag: Schema.tag<`${string}/get-share-link`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-            target: Schema.optional<typeof Schema.String>;
-            copyToClipboard: Schema.optional<typeof Schema.Boolean>;
-        }>;
-        output: typeof Schema.String;
-    }>;
-    export class GetShareLink extends GetShareLink_base {
-    }
-    const Lock_base: Schema.TaggedClass<Lock, `${string}/lock`, {
-        readonly _tag: Schema.tag<`${string}/lock`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class Lock extends Lock_base {
-    }
-    const Unlock_base: Schema.TaggedClass<Unlock, `${string}/unlock`, {
-        readonly _tag: Schema.tag<`${string}/unlock`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class Unlock extends Unlock_base {
-    }
-    const Rename_base: Schema.TaggedClass<Rename, `${string}/rename`, {
-        readonly _tag: Schema.tag<`${string}/rename`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-            caller: Schema.optional<typeof Schema.String>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class Rename extends Rename_base {
-    }
-    const OpenSettings_base: Schema.TaggedClass<OpenSettings, `${string}/open-settings`, {
-        readonly _tag: Schema.tag<`${string}/open-settings`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class OpenSettings extends OpenSettings_base {
-    }
-    const Open_base: Schema.TaggedClass<Open, `${string}/open`, {
-        readonly _tag: Schema.tag<`${string}/open`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class Open extends Open_base {
-    }
-    const Close_base: Schema.TaggedClass<Close, `${string}/close`, {
-        readonly _tag: Schema.tag<`${string}/close`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class Close extends Close_base {
-    }
-    const Migrate_base: Schema.TaggedClass<Migrate, `${string}/migrate`, {
-        readonly _tag: Schema.tag<`${string}/migrate`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-            version: Schema.optional<typeof Schema.String>;
-        }>;
-        output: typeof Schema.Boolean;
-    }>;
-    export class Migrate extends Migrate_base {
-    }
-    export const StoredSchemaForm: Schema.Struct<{
+    type DeleteFieldOutput = Schema.Schema.Type<typeof DeleteFieldOutput>;
+    const DeleteField: Omit<{
+        readonly meta: {
+            readonly key: `${string}/delete-field`;
+            readonly name: "Delete Field";
+            readonly description: "Delete a field from a view.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                view: Type.Obj<View.View, Schema.Struct.Fields>;
+                fieldId: typeof Schema.String;
+            }>;
+            readonly output: Schema.Struct<{
+                field: Schema.Struct<{
+                    id: typeof Schema.String;
+                    path: Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>;
+                    visible: Schema.optional<typeof Schema.Boolean>;
+                    referencePath: Schema.optional<Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>>;
+                }>;
+                props: Schema.SchemaClass<any, any, never>;
+                index: Schema.SchemaClass<number, number, never>;
+            }>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const OpenCreateObject: Omit<{
+        readonly meta: {
+            readonly key: `${string}/open-create-object`;
+            readonly name: "Open Create Object Dialog";
+            readonly description: "Open the create object dialog.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                target: Schema.Union<[Schema.Schema<Database.Database, Database.Database, never>, Type.Obj<{
+                    readonly name?: string | undefined;
+                    readonly objects: readonly import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+                }, Schema.Struct.Fields>]>;
+                views: Schema.optional<typeof Schema.Boolean>;
+                typename: Schema.optional<typeof Schema.String>;
+                initialFormValues: Schema.optional<typeof Schema.Any>;
+                navigable: Schema.optional<typeof Schema.Boolean>;
+                onCreateObject: Schema.optional<typeof Schema.Any>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const OpenCreateSpace: Omit<{
+        readonly meta: {
+            readonly key: `${string}/open-create-space`;
+            readonly name: "Open Create Space Dialog";
+            readonly description: "Open the create space dialog.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: typeof Schema.Void;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const Migrate: Omit<{
+        readonly meta: {
+            readonly key: `${string}/migrate`;
+            readonly name: "Migrate Space";
+            readonly description: "Migrate a space to a new version.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+                version: Schema.optional<typeof Schema.String>;
+            }>;
+            readonly output: typeof Schema.Boolean;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const Snapshot: Omit<{
+        readonly meta: {
+            readonly key: `${string}/snapshot`;
+            readonly name: "Create Snapshot";
+            readonly description: "Create a snapshot of the space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                db: Schema.Schema<Database.Database, Database.Database, never>;
+                query: Schema.optional<Schema.Schema<QueryAST.QuerySelectClause | QueryAST.QueryFilterClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryUnionClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryOrderClause | QueryAST.QueryOptionsClause | QueryAST.QueryLimitClause | QueryAST.QueryFromClause, QueryAST.QuerySelectClause | QueryAST.QueryFilterClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryUnionClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryOrderClause | QueryAST.QueryOptionsClause | QueryAST.QueryLimitClause | QueryAST.QueryFromClause, never>>;
+            }>;
+            readonly output: Schema.Struct<{
+                snapshot: Schema.instanceOf<Blob>;
+            }>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const Rename: Omit<{
+        readonly meta: {
+            readonly key: `${string}/rename`;
+            readonly name: "Rename Space";
+            readonly description: "Rename a space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+                caller: Schema.optional<typeof Schema.String>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const RenameObject: Omit<{
+        readonly meta: {
+            readonly key: `${string}/rename-object`;
+            readonly name: "Rename Object";
+            readonly description: "Rename an object.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                object: Type.Obj<Obj.Unknown, Schema.Struct.Fields>;
+                caller: Schema.optional<typeof Schema.String>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const OpenMembers: Omit<{
+        readonly meta: {
+            readonly key: `${string}/open-members`;
+            readonly name: "Open Members";
+            readonly description: "Open the members panel for a space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const GetShareLink: Omit<{
+        readonly meta: {
+            readonly key: `${string}/get-share-link`;
+            readonly name: "Get Share Link";
+            readonly description: "Get a shareable link for a space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
+                target: Schema.optional<typeof Schema.String>;
+                copyToClipboard: Schema.optional<typeof Schema.Boolean>;
+            }>;
+            readonly output: typeof Schema.String;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const StoredSchemaForm: Schema.Struct<{
         name: Schema.optional<typeof Schema.String>;
         typename: Schema.optional<Schema.SchemaClass<string, string, never>>;
     }>;
-    const UseStaticSchema_base: Schema.TaggedClass<UseStaticSchema, `${string}/use-static-schema`, {
-        readonly _tag: Schema.tag<`${string}/use-static-schema`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-            typename: typeof Schema.String;
-        }>;
-        output: Schema.Struct<{}>;
-    }>;
-    export class UseStaticSchema extends UseStaticSchema_base {
-    }
-    const AddSchema_base: Schema.TaggedClass<AddSchema, `${string}/add-schema`, {
-        readonly _tag: Schema.tag<`${string}/add-schema`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-            name: Schema.optional<typeof Schema.String>;
-            typename: Schema.optional<typeof Schema.String>;
-            version: Schema.optional<typeof Schema.String>;
-            schema: typeof Schema.Any;
-        }>;
-        output: Schema.Struct<{
-            id: typeof Schema.String;
-            object: import("@dxos/echo/internal").EchoTypeSchema<Schema.Struct<{
+    const UseStaticSchema: Omit<{
+        readonly meta: {
+            readonly key: `${string}/use-static-schema`;
+            readonly name: "Use Static Schema";
+            readonly description: "Use a static schema in the space.";
+        };
+        readonly services: readonly [typeof Capability.Service, typeof Plugin.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                db: Schema.Schema<Database.Database, Database.Database, never>;
+                typename: typeof Schema.String;
+                show: Schema.optional<typeof Schema.Boolean>;
+            }>;
+            readonly output: Schema.Struct<{}>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const AddSchema: Omit<{
+        readonly meta: {
+            readonly key: `${string}/add-schema`;
+            readonly name: "Add Schema";
+            readonly description: "Add a schema to the space.";
+        };
+        readonly services: readonly [typeof Capability.Service, typeof Plugin.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                db: Schema.Schema<Database.Database, Database.Database, never>;
                 name: Schema.optional<typeof Schema.String>;
-                typename: Schema.filter<typeof Schema.String>;
-                version: Schema.filter<typeof Schema.String>;
-                jsonSchema: Schema.Schema<Type.JsonSchema, Type.JsonSchema, never>;
-            }>, {}>;
-            schema: Schema.instanceOf<EchoSchema<unknown, unknown>>;
-        }>;
-    }>;
-    export class AddSchema extends AddSchema_base {
-    }
-    const DeleteField_base: Schema.TaggedClass<DeleteField, `${string}/delete-field`, {
-        readonly _tag: Schema.tag<`${string}/delete-field`>;
-    } & {
-        input: Schema.Struct<{
-            view: Schema.Schema<DataType.View, import("@dxos/schema").ViewEncoded, never>;
-            fieldId: typeof Schema.String;
-            deletionData: Schema.optional<Schema.Struct<{
-                field: Schema.mutable<Schema.Struct<{
+                typename: Schema.optional<typeof Schema.String>;
+                version: Schema.optional<typeof Schema.String>;
+                schema: typeof Schema.Any;
+                show: Schema.optional<typeof Schema.Boolean>;
+            }>;
+            readonly output: Schema.Struct<{
+                id: typeof Schema.String;
+                object: Type.Obj<import("@dxos/echo/internal").PersistentSchema, Schema.Struct.Fields>;
+                schema: Schema.instanceOf<import("@dxos/echo/internal").EchoSchema<unknown, unknown>>;
+            }>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const AddRelation: Omit<{
+        readonly meta: {
+            readonly key: `${string}/add-relation`;
+            readonly name: "Add Relation";
+            readonly description: "Add a relation between objects.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                db: Schema.Schema<Database.Database, Database.Database, never>;
+                schema: typeof Schema.Any;
+                source: Type.Obj<Obj.Unknown, Schema.Struct.Fields>;
+                target: Type.Obj<Obj.Unknown, Schema.Struct.Fields>;
+                fields: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+            }>;
+            readonly output: Schema.Struct<{
+                relation: typeof Schema.Any;
+            }>;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    const DuplicateObject: Omit<{
+        readonly meta: {
+            readonly key: `${string}/duplicate-object`;
+            readonly name: "Duplicate Object";
+            readonly description: "Duplicate an object.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                object: Type.Obj<Obj.Unknown, Schema.Struct.Fields>;
+                target: Schema.Union<[Schema.Schema<Database.Database, Database.Database, never>, Type.Obj<{
+                    readonly name?: string | undefined;
+                    readonly objects: readonly import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+                }, Schema.Struct.Fields>]>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    /**
+     * Restore a deleted field to a view (inverse of DeleteField).
+     */
+    const RestoreField: Omit<{
+        readonly meta: {
+            readonly key: `${string}/restore-field`;
+            readonly name: "Restore Field";
+            readonly description: "Restore a deleted field to a view.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                view: Type.Obj<View.View, Schema.Struct.Fields>;
+                field: Schema.Struct<{
                     id: typeof Schema.String;
                     path: Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>;
                     visible: Schema.optional<typeof Schema.Boolean>;
                     referencePath: Schema.optional<Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>>;
-                }>>;
-                props: typeof Schema.Any;
-                index: typeof Schema.Number;
-            }>>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class DeleteField extends DeleteField_base {
-    }
-    const OpenCreateObject_base: Schema.TaggedClass<OpenCreateObject, `${string}/open-create-object`, {
-        readonly _tag: Schema.tag<`${string}/open-create-object`>;
-    } & {
-        input: Schema.Struct<{
-            target: Schema.Union<[Schema.Schema<Space, Space, never>, Type.obj<Schema.Struct<{
-                name: Schema.optional<typeof Schema.String>;
-                objects: Schema.mutable<Schema.Array$<Type.ref<Schema.Schema<Type.Expando, {
-                    [x: string]: any;
-                    id: string;
-                }, never>>>>;
-            }>>]>;
-            views: Schema.optional<typeof Schema.Boolean>;
-            typename: Schema.optional<typeof Schema.String>;
-            initialFormValues: Schema.optional<typeof Schema.Any>;
-            navigable: Schema.optional<typeof Schema.Boolean>;
-            onCreateObject: Schema.optional<typeof Schema.Any>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class OpenCreateObject extends OpenCreateObject_base {
-    }
-    const AddObject_base: Schema.TaggedClass<AddObject, `${string}/add-object`, {
-        readonly _tag: Schema.tag<`${string}/add-object`>;
-    } & {
-        input: Schema.Struct<{
-            object: Schema.Schema<any, any, never>;
-            target: Schema.Union<[Schema.Schema<Space, Space, never>, Type.obj<Schema.Struct<{
-                name: Schema.optional<typeof Schema.String>;
-                objects: Schema.mutable<Schema.Array$<Type.ref<Schema.Schema<Type.Expando, {
-                    [x: string]: any;
-                    id: string;
-                }, never>>>>;
-            }>>]>;
-            hidden: Schema.optional<typeof Schema.Boolean>;
-        }>;
-        output: Schema.Struct<{
-            id: typeof Schema.String;
-            subject: Schema.Array$<typeof Schema.String>;
-            object: Schema.Schema<any, any, never>;
-        }>;
-    }>;
-    export class AddObject extends AddObject_base {
-    }
-    const AddRelation_base: Schema.TaggedClass<AddRelation, `${string}/add-relation`, {
-        readonly _tag: Schema.tag<`${string}/add-relation`>;
-    } & {
-        input: Schema.Struct<{
-            space: Schema.Schema<Space, Space, never>;
-            schema: typeof Schema.Any;
-            source: Schema.Schema<Type.Expando, {
-                [x: string]: any;
-                id: string;
-            }, never>;
-            target: Schema.Schema<Type.Expando, {
-                [x: string]: any;
-                id: string;
-            }, never>;
-            fields: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
-        }>;
-        output: Schema.Struct<{
-            relation: typeof Schema.Any;
-        }>;
-    }>;
-    export class AddRelation extends AddRelation_base {
-    }
-    export const DeletionData: Schema.Struct<{
-        objects: Schema.Array$<Schema.Schema<any, any, never>>;
-        parentCollection: Type.obj<Schema.Struct<{
-            name: Schema.optional<typeof Schema.String>;
-            objects: Schema.mutable<Schema.Array$<Type.ref<Schema.Schema<Type.Expando, {
-                [x: string]: any;
-                id: string;
-            }, never>>>>;
-        }>>;
-        indices: Schema.Array$<typeof Schema.Number>;
-        nestedObjectsList: Schema.Array$<Schema.Array$<Schema.Schema<any, any, never>>>;
-        wasActive: Schema.Array$<typeof Schema.String>;
-    }>;
-    export type DeletionData = Schema.Schema.Type<typeof DeletionData>;
-    const RemoveObjects_base: Schema.TaggedClass<RemoveObjects, `${string}/remove-objects`, {
-        readonly _tag: Schema.tag<`${string}/remove-objects`>;
-    } & {
-        input: Schema.Struct<{
-            objects: Schema.Array$<Schema.Schema<any, any, never>>;
-            target: Schema.optional<Type.obj<Schema.Struct<{
-                name: Schema.optional<typeof Schema.String>;
-                objects: Schema.mutable<Schema.Array$<Type.ref<Schema.Schema<Type.Expando, {
-                    [x: string]: any;
-                    id: string;
-                }, never>>>>;
-            }>>>;
-            deletionData: Schema.optional<Schema.Struct<{
-                objects: Schema.Array$<Schema.Schema<any, any, never>>;
-                parentCollection: Type.obj<Schema.Struct<{
-                    name: Schema.optional<typeof Schema.String>;
-                    objects: Schema.mutable<Schema.Array$<Type.ref<Schema.Schema<Type.Expando, {
-                        [x: string]: any;
-                        id: string;
-                    }, never>>>>;
-                }>>;
+                }>;
+                props: Schema.SchemaClass<any, any, never>;
+                index: Schema.SchemaClass<number, number, never>;
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
+    /**
+     * Restore deleted objects to a space (inverse of RemoveObjects).
+     */
+    const RestoreObjects: Omit<{
+        readonly meta: {
+            readonly key: `${string}/restore-objects`;
+            readonly name: "Restore Objects";
+            readonly description: "Restore deleted objects to a space.";
+        };
+        readonly services: readonly [typeof Capability.Service];
+        readonly schema: {
+            readonly input: Schema.Struct<{
+                objects: Schema.Array$<Type.Obj<Obj.Unknown, Schema.Struct.Fields>>;
+                parentCollection: Type.Obj<{
+                    readonly name?: string | undefined;
+                    readonly objects: readonly import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+                }, Schema.Struct.Fields>;
                 indices: Schema.Array$<typeof Schema.Number>;
-                nestedObjectsList: Schema.Array$<Schema.Array$<Schema.Schema<any, any, never>>>;
+                nestedObjectsList: Schema.Array$<Schema.Array$<Type.Obj<Obj.Unknown, Schema.Struct.Fields>>>;
                 wasActive: Schema.Array$<typeof Schema.String>;
-            }>>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class RemoveObjects extends RemoveObjects_base {
-    }
-    const RenameObject_base: Schema.TaggedClass<RenameObject, `${string}/rename-object`, {
-        readonly _tag: Schema.tag<`${string}/rename-object`>;
-    } & {
-        input: Schema.Struct<{
-            object: Schema.Schema<any, any, never>;
-            caller: Schema.optional<typeof Schema.String>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class RenameObject extends RenameObject_base {
-    }
-    const DuplicateObject_base: Schema.TaggedClass<DuplicateObject, `${string}/duplicate-object`, {
-        readonly _tag: Schema.tag<`${string}/duplicate-object`>;
-    } & {
-        input: Schema.Struct<{
-            object: Schema.Schema<any, any, never>;
-            target: Schema.Union<[Schema.Schema<Space, Space, never>, Type.obj<Schema.Struct<{
-                name: Schema.optional<typeof Schema.String>;
-                objects: Schema.mutable<Schema.Array$<Type.ref<Schema.Schema<Type.Expando, {
-                    [x: string]: any;
-                    id: string;
-                }, never>>>>;
-            }>>]>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class DuplicateObject extends DuplicateObject_base {
-    }
-    const WaitForObject_base: Schema.TaggedClass<WaitForObject, `${string}/wait-for-object`, {
-        readonly _tag: Schema.tag<`${string}/wait-for-object`>;
-    } & {
-        input: Schema.Struct<{
-            id: Schema.optional<typeof Schema.String>;
-        }>;
-        output: typeof Schema.Void;
-    }>;
-    export class WaitForObject extends WaitForObject_base {
-    }
-    export {};
-}
-export declare namespace CollectionAction {
-    const Create_base_1: Schema.TaggedClass<Create, "dxos.org/plugin/collection/action/create", {
-        readonly _tag: Schema.tag<"dxos.org/plugin/collection/action/create">;
-    } & {
-        input: Schema.Struct<{
-            name: Schema.optional<typeof Schema.String>;
-        }>;
-        output: Schema.Struct<{
-            object: Type.obj<Schema.Struct<{
-                name: Schema.optional<typeof Schema.String>;
-                objects: Schema.mutable<Schema.Array$<Type.ref<Schema.Schema<Type.Expando, {
-                    [x: string]: any;
-                    id: string;
-                }, never>>>>;
-            }>>;
-        }>;
-    }>;
-    export class Create extends Create_base_1 {
-    }
-    export const QueryCollectionForm: Schema.Struct<{
-        name: Schema.optional<typeof Schema.String>;
-        typename: Schema.SchemaClass<string, string, never>;
-    }>;
-    const CreateQueryCollection_base: Schema.TaggedClass<CreateQueryCollection, "dxos.org/plugin/collection/action/create-query-collection", {
-        readonly _tag: Schema.tag<"dxos.org/plugin/collection/action/create-query-collection">;
-    } & {
-        input: Schema.Struct<{
-            name: Schema.optional<typeof Schema.String>;
-            typename: Schema.SchemaClass<string, string, never>;
-        }>;
-        output: Schema.Struct<{
-            object: Schema.Schema<any, any, never>;
-        }>;
-    }>;
-    export class CreateQueryCollection extends CreateQueryCollection_base {
-    }
-    export {};
+            }>;
+            readonly output: typeof Schema.Void;
+        };
+    }, "executionMode"> & import("effect/Pipeable").Pipeable & {
+        readonly executionMode: "sync" | "async";
+    };
 }
 //# sourceMappingURL=types.d.ts.map