@dxos/protocols 0.8.4-main.fffef41 → 0.8.4-staging.ac66bdf99f

package/dist/src/errors/errors.d.ts

@@ -1,82 +1,659 @@
+import { BaseError } from '@dxos/errors';
 import { PublicKey } from '@dxos/keys';
-import type { ObjectId } from '../types.js';
-import { ApiError, BaseError, DatabaseError, SystemError } from './base-errors.js';
+import type { ObjectId } from '../types.ts';
+declare const RpcClosedError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "RpcClosedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RpcClosedError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "RpcClosedError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "RpcClosedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RpcClosedError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
 /**
  * Thrown when request was terminated because the RPC endpoint has been closed.
  */
-export declare class RpcClosedError extends SystemError {
-    constructor();
+export declare class RpcClosedError extends RpcClosedError_base {
 }
+declare const RpcNotOpenError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "RpcNotOpenError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RpcNotOpenError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "RpcNotOpenError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "RpcNotOpenError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RpcNotOpenError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
 /**
  * Thrown when `request` is called when RPC has not been opened.
  */
-export declare class RpcNotOpenError extends SystemError {
-    constructor();
+export declare class RpcNotOpenError extends RpcNotOpenError_base {
 }
-export declare class CancelledError extends SystemError {
-    constructor(message?: string, context?: Record<string, any>);
+declare const CancelledError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "CancelledError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "CancelledError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "CancelledError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "CancelledError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "CancelledError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class CancelledError extends CancelledError_base {
 }
-export declare class InvalidConfigError extends ApiError {
-    constructor(message?: string, context?: Record<string, any>);
+declare const InvalidConfigError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "InvalidConfigError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidConfigError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "InvalidConfigError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "InvalidConfigError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidConfigError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvalidConfigError extends InvalidConfigError_base {
 }
+declare const RemoteServiceConnectionError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "RemoteServiceConnectionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RemoteServiceConnectionError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "RemoteServiceConnectionError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "RemoteServiceConnectionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RemoteServiceConnectionError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
 /**
  * Explicit failure to connect with remote client services.
  */
-export declare class RemoteServiceConnectionError extends ApiError {
-    constructor(message?: string, context?: Record<string, any>);
+export declare class RemoteServiceConnectionError extends RemoteServiceConnectionError_base {
 }
+declare const RemoteServiceConnectionTimeout_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "RemoteServiceConnectionTimeout";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RemoteServiceConnectionTimeout";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "RemoteServiceConnectionTimeout";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "RemoteServiceConnectionTimeout";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RemoteServiceConnectionTimeout";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
 /**
  * Failed to open a connection to remote client services.
  */
-export declare class RemoteServiceConnectionTimeout extends ApiError {
-    constructor(message?: string, context?: Record<string, any>);
+export declare class RemoteServiceConnectionTimeout extends RemoteServiceConnectionTimeout_base {
 }
-export declare class DataCorruptionError extends SystemError {
-    constructor(message?: string, context?: Record<string, any>);
+declare const DataCorruptionError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "DataCorruptionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "DataCorruptionError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "DataCorruptionError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "DataCorruptionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "DataCorruptionError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class DataCorruptionError extends DataCorruptionError_base {
 }
-export declare class InvalidInvitationExtensionRoleError extends SystemError {
-    constructor(message?: string, context?: Record<string, any>);
+declare const InvalidInvitationExtensionRoleError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "InvalidInvitationExtensionRoleError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidInvitationExtensionRoleError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "InvalidInvitationExtensionRoleError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "InvalidInvitationExtensionRoleError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidInvitationExtensionRoleError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvalidInvitationExtensionRoleError extends InvalidInvitationExtensionRoleError_base {
 }
-export declare class IdentityNotInitializedError extends DatabaseError {
-    constructor(message?: string, context?: Record<string, any>);
+declare const IdentityNotInitializedError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "IdentityNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "IdentityNotInitializedError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "IdentityNotInitializedError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "IdentityNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "IdentityNotInitializedError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class IdentityNotInitializedError extends IdentityNotInitializedError_base {
 }
-export declare class InvalidInvitationError extends DatabaseError {
-    constructor(message?: string, context?: Record<string, any>);
+declare const InvalidInvitationError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "InvalidInvitationError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidInvitationError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "InvalidInvitationError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "InvalidInvitationError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidInvitationError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvalidInvitationError extends InvalidInvitationError_base {
 }
-export declare class AlreadyJoinedError extends DatabaseError {
-    constructor(message?: string, context?: Record<string, any>);
+declare const AlreadyJoinedError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "AlreadyJoinedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "AlreadyJoinedError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "AlreadyJoinedError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "AlreadyJoinedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "AlreadyJoinedError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class AlreadyJoinedError extends AlreadyJoinedError_base {
 }
-export declare class ConnectionResetError extends BaseError {
-    constructor(message?: string, context?: any);
+declare const ConnectionResetError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "ConnectionResetError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ConnectionResetError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "ConnectionResetError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "ConnectionResetError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ConnectionResetError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class ConnectionResetError extends ConnectionResetError_base {
 }
-export declare class TimeoutError extends BaseError {
-    constructor(message?: string, context?: any);
+declare const TimeoutError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "TimeoutError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TimeoutError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "TimeoutError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "TimeoutError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TimeoutError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class TimeoutError extends TimeoutError_base {
 }
-export declare class ProtocolError extends BaseError {
-    constructor(message?: string, context?: any);
+declare const ProtocolError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "ProtocolError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ProtocolError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "ProtocolError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "ProtocolError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ProtocolError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class ProtocolError extends ProtocolError_base {
 }
-export declare class ConnectivityError extends BaseError {
-    constructor(message?: string, context?: any);
+declare const ConnectivityError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "ConnectivityError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ConnectivityError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "ConnectivityError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "ConnectivityError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ConnectivityError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class ConnectivityError extends ConnectivityError_base {
 }
-export declare class RateLimitExceededError extends BaseError {
-    constructor(message?: string, context?: any);
+declare const RateLimitExceededError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "RateLimitExceededError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RateLimitExceededError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "RateLimitExceededError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "RateLimitExceededError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RateLimitExceededError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class RateLimitExceededError extends RateLimitExceededError_base {
 }
-export declare class UnknownProtocolError extends BaseError {
-    constructor(message?: string, innerError?: Error);
+declare const UnknownProtocolError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "UnknownProtocolError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "UnknownProtocolError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "UnknownProtocolError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "UnknownProtocolError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "UnknownProtocolError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class UnknownProtocolError extends UnknownProtocolError_base {
 }
-export declare class InvalidStorageVersionError extends DatabaseError {
+declare const InvalidStorageVersionError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "InvalidStorageVersionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidStorageVersionError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "InvalidStorageVersionError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "InvalidStorageVersionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidStorageVersionError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvalidStorageVersionError extends InvalidStorageVersionError_base {
     constructor(expected: number, actual: number);
 }
-export declare class SpaceNotFoundError extends DatabaseError {
+declare const SpaceNotFoundError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "SpaceNotFoundError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "SpaceNotFoundError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "SpaceNotFoundError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "SpaceNotFoundError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "SpaceNotFoundError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class SpaceNotFoundError extends SpaceNotFoundError_base {
     constructor(spaceKey: PublicKey);
 }
-export declare class EntityNotFoundError extends DatabaseError {
+declare const EntityNotFoundError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "EntityNotFoundError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "EntityNotFoundError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "EntityNotFoundError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "EntityNotFoundError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "EntityNotFoundError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class EntityNotFoundError extends EntityNotFoundError_base {
     constructor(entityId: ObjectId);
 }
-export declare class UnknownModelError extends DatabaseError {
+declare const UnknownModelError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "UnknownModelError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "UnknownModelError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "UnknownModelError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "UnknownModelError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "UnknownModelError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class UnknownModelError extends UnknownModelError_base {
     constructor(model: string);
 }
-export declare class AuthorizationError extends ApiError {
-    constructor(message?: string, context?: any);
+declare const AuthorizationError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        name: "AuthorizationError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "AuthorizationError";
+        stack?: string;
+        cause?: unknown;
+    };
+    name: "AuthorizationError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, "cause"> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        name: "AuthorizationError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "AuthorizationError";
+        stack?: string;
+        cause?: unknown;
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class AuthorizationError extends AuthorizationError_base {
 }
+export {};
 //# sourceMappingURL=errors.d.ts.map