@dxos/protocols 0.8.3 → 0.8.4-main.1068cf700f

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

@@ -0,0 +1,659 @@
+import { BaseError } from '@dxos/errors';
+import { PublicKey } from '@dxos/keys';
+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 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 RpcNotOpenError_base {
+}
+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 {
+}
+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 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 RemoteServiceConnectionTimeout_base {
+}
+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 {
+}
+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 {
+}
+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 {
+}
+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 {
+}
+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 {
+}
+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 {
+}
+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 {
+}
+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 {
+}
+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 {
+}
+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 {
+}
+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 {
+}
+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);
+}
+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);
+}
+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);
+}
+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);
+}
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;;;qBA8BH,CAAC;;;;;;;;;;;;;;;AA1B1C;;GAEG;AACH,qBAAa,cAAe,SAAQ,mBAGnC;CAAG;;;;;;;;;;;;;qBAoBqC,CAAC;;;;;;;;;;;;;;;AAhB1C;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBAA+D;CAAG;;;;;;;;;;;;;qBAa9D,CAAC;;;;;;;;;;;;;;;AAT1C,qBAAa,cAAe,SAAQ,mBAAkC;CAAG;;;;;;;;;;;;;qBAShC,CAAC;;;;;;;;;;;;;;;AAL1C,qBAAa,kBAAmB,SAAQ,uBAAsC;CAAG;;;;;;;;;;;;;qBAKxC,CAAC;;;;;;;;;;;;;;;AAD1C;;GAEG;AACH,qBAAa,4BAA6B,SAAQ,iCAAgD;CAAG;;;;;;;;;;;;;qBAF5D,CAAC;;;;;;;;;;;;;;;AAM1C;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,mCAAkD;CAAG;;;;;;;;;;;;;qBAThE,CAAC;;;;;;;;;;;;;;;AAa1C,qBAAa,mBAAoB,SAAQ,wBAAuC;CAAG;;;;;;;;;;;;;qBAb1C,CAAC;;;;;;;;;;;;;;;AAiB1C,qBAAa,mCAAoC,SAAQ,wCAAuD;CAAG;;;;;;;;;;;;;qBAjB1E,CAAC;;;;;;;;;;;;;;;AAqB1C,qBAAa,2BAA4B,SAAQ,gCAA+C;CAAG;;;;;;;;;;;;;qBArB1D,CAAC;;;;;;;;;;;;;;;AAyB1C,qBAAa,sBAAuB,SAAQ,2BAA0C;CAAG;;;;;;;;;;;;;qBAzBhD,CAAC;;;;;;;;;;;;;;;AA6B1C,qBAAa,kBAAmB,SAAQ,uBAAsC;CAAG;;;;;;;;;;;;;qBA7BxC,CAAC;;;;;;;;;;;;;;;AAiC1C,qBAAa,oBAAqB,SAAQ,yBAAwC;CAAG;;;;;;;;;;;;;qBAjC5C,CAAC;;;;;;;;;;;;;;;AAqC1C,qBAAa,YAAa,SAAQ,iBAAgC;CAAG;;;;;;;;;;;;;qBArC5B,CAAC;;;;;;;;;;;;;;;AA0C1C,qBAAa,aAAc,SAAQ,kBAAiC;CAAG;;;;;;;;;;;;;qBA1C9B,CAAC;;;;;;;;;;;;;;;AA+C1C,qBAAa,iBAAkB,SAAQ,sBAAqC;CAAG;;;;;;;;;;;;;qBA/CtC,CAAC;;;;;;;;;;;;;;;AAmD1C,qBAAa,sBAAuB,SAAQ,2BAA0C;CAAG;;;;;;;;;;;;;qBAnDhD,CAAC;;;;;;;;;;;;;;;AAwD1C,qBAAa,oBAAqB,SAAQ,yBAAwC;CAAG;;;;;;;;;;;;;qBAxD5C,CAAC;;;;;;;;;;;;;;;AA4D1C,qBAAa,0BAA2B,SAAQ,+BAG/C;gBACa,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAG7C;;;;;;;;;;;;;qBAnEwC,CAAC;;;;;;;;;;;;;;;AAyE1C,qBAAa,kBAAmB,SAAQ,uBAA0D;gBACpF,QAAQ,EAAE,SAAS;CAGhC;;;;;;;;;;;;;qBA7EwC,CAAC;;;;;;;;;;;;;;;AAmF1C,qBAAa,mBAAoB,SAAQ,wBAA0D;gBACrF,QAAQ,EAAE,QAAQ;CAG/B;;;;;;;;;;;;;qBAvFwC,CAAC;;;;;;;;;;;;;;;AA6F1C,qBAAa,iBAAkB,SAAQ,sBAAuD;gBAChF,KAAK,EAAE,MAAM;CAG1B;;;;;;;;;;;;;qBAjGwC,CAAC;;;;;;;;;;;;;;;AAuG1C,qBAAa,kBAAmB,SAAQ,uBAAsC;CAAG"}