@dxos/protocols 0.8.3 → 0.8.4-main.1c7ec43d41

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): {
+        cause?: unknown;
+        stack?: string;
+        name: "RpcClosedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RpcClosedError";
+    };
+    isError(error: unknown): error is Error;
+    name: "RpcClosedError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "RpcClosedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RpcClosedError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "RpcNotOpenError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RpcNotOpenError";
+    };
+    isError(error: unknown): error is Error;
+    name: "RpcNotOpenError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "RpcNotOpenError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RpcNotOpenError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "CancelledError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "CancelledError";
+    };
+    isError(error: unknown): error is Error;
+    name: "CancelledError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "CancelledError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "CancelledError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidConfigError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidConfigError";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidConfigError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidConfigError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidConfigError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "RemoteServiceConnectionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RemoteServiceConnectionError";
+    };
+    isError(error: unknown): error is Error;
+    name: "RemoteServiceConnectionError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "RemoteServiceConnectionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RemoteServiceConnectionError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "RemoteServiceConnectionTimeout";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RemoteServiceConnectionTimeout";
+    };
+    isError(error: unknown): error is Error;
+    name: "RemoteServiceConnectionTimeout";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "RemoteServiceConnectionTimeout";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RemoteServiceConnectionTimeout";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "DataCorruptionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "DataCorruptionError";
+    };
+    isError(error: unknown): error is Error;
+    name: "DataCorruptionError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "DataCorruptionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "DataCorruptionError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidInvitationExtensionRoleError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidInvitationExtensionRoleError";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidInvitationExtensionRoleError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidInvitationExtensionRoleError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidInvitationExtensionRoleError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "IdentityNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "IdentityNotInitializedError";
+    };
+    isError(error: unknown): error is Error;
+    name: "IdentityNotInitializedError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "IdentityNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "IdentityNotInitializedError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidInvitationError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidInvitationError";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidInvitationError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidInvitationError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidInvitationError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "AlreadyJoinedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "AlreadyJoinedError";
+    };
+    isError(error: unknown): error is Error;
+    name: "AlreadyJoinedError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "AlreadyJoinedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "AlreadyJoinedError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "ConnectionResetError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ConnectionResetError";
+    };
+    isError(error: unknown): error is Error;
+    name: "ConnectionResetError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "ConnectionResetError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ConnectionResetError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "TimeoutError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TimeoutError";
+    };
+    isError(error: unknown): error is Error;
+    name: "TimeoutError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "TimeoutError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TimeoutError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "ProtocolError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ProtocolError";
+    };
+    isError(error: unknown): error is Error;
+    name: "ProtocolError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "ProtocolError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ProtocolError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "ConnectivityError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ConnectivityError";
+    };
+    isError(error: unknown): error is Error;
+    name: "ConnectivityError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "ConnectivityError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ConnectivityError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "RateLimitExceededError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RateLimitExceededError";
+    };
+    isError(error: unknown): error is Error;
+    name: "RateLimitExceededError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "RateLimitExceededError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "RateLimitExceededError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "UnknownProtocolError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "UnknownProtocolError";
+    };
+    isError(error: unknown): error is Error;
+    name: "UnknownProtocolError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "UnknownProtocolError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "UnknownProtocolError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidStorageVersionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidStorageVersionError";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidStorageVersionError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidStorageVersionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidStorageVersionError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "SpaceNotFoundError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "SpaceNotFoundError";
+    };
+    isError(error: unknown): error is Error;
+    name: "SpaceNotFoundError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "SpaceNotFoundError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "SpaceNotFoundError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "EntityNotFoundError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "EntityNotFoundError";
+    };
+    isError(error: unknown): error is Error;
+    name: "EntityNotFoundError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "EntityNotFoundError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "EntityNotFoundError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "UnknownModelError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "UnknownModelError";
+    };
+    isError(error: unknown): error is Error;
+    name: "UnknownModelError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "UnknownModelError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "UnknownModelError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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): {
+        cause?: unknown;
+        stack?: string;
+        name: "AuthorizationError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "AuthorizationError";
+    };
+    isError(error: unknown): error is Error;
+    name: "AuthorizationError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "AuthorizationError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "AuthorizationError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    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;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG5C;;GAEG;AACH,qBAAa,cAAe,SAAQ,mBAGnC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIJ;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBAA+D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIvG,qBAAa,cAAe,SAAQ,mBAAkC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIzE,qBAAa,kBAAmB,SAAQ,uBAAsC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIjF;;GAEG;AACH,qBAAa,4BAA6B,SAAQ,iCAAgD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIrG;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,mCAAkD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIzG,qBAAa,mBAAoB,SAAQ,wBAAuC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAInF,qBAAa,mCAAoC,SAAQ,wCAAuD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAInH,qBAAa,2BAA4B,SAAQ,gCAA+C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAInG,qBAAa,sBAAuB,SAAQ,2BAA0C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIzF,qBAAa,kBAAmB,SAAQ,uBAAsC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIjF,qBAAa,oBAAqB,SAAQ,yBAAwC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIrF,qBAAa,YAAa,SAAQ,iBAAgC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKrE,qBAAa,aAAc,SAAQ,kBAAiC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKvE,qBAAa,iBAAkB,SAAQ,sBAAqC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI/E,qBAAa,sBAAuB,SAAQ,2BAA0C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKzF,qBAAa,oBAAqB,SAAQ,yBAAwC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIrF,qBAAa,0BAA2B,SAAQ,+BAG/C;IACC,YAAY,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAE3C;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMD,qBAAa,kBAAmB,SAAQ,uBAA0D;IAChG,YAAY,QAAQ,EAAE,SAAS,EAE9B;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMD,qBAAa,mBAAoB,SAAQ,wBAA0D;IACjG,YAAY,QAAQ,EAAE,QAAQ,EAE7B;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMD,qBAAa,iBAAkB,SAAQ,sBAAuD;IAC5F,YAAY,KAAK,EAAE,MAAM,EAExB;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMD,qBAAa,kBAAmB,SAAQ,uBAAsC;CAAG"}