@kurrent/kurrentdb-client 0.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,348 @@
+import type { Readable } from "stream";
+import type { Client as GRPCClient, ClientOptions as GRPCClientOptions, ChannelCredentials } from "@grpc/grpc-js";
+import { MemberInfo as GrpcMemberInfo } from "../../generated/gossip_pb";
+import VNodeState = GrpcMemberInfo.VNodeState;
+import type { ResolvedEvent, AllStreamResolvedEvent, EventType, PersistentSubscriptionToAllResolvedEvent, PersistentSubscriptionToStreamResolvedEvent } from "./events";
+import type * as constants from "../constants";
+export interface BaseOptions {
+    /**
+     * Overwrite the default credentials.
+     */
+    credentials?: Credentials;
+    /**
+     * Command requires a leader node.
+     */
+    requiresLeader?: boolean;
+    /**
+     * An optional length of time (in milliseconds) to override the default deadline.
+     */
+    deadline?: number;
+}
+/**
+ * A structure referring to a potential logical record position in the KurrentDB transaction file.
+ */
+export type Position = {
+    commit: bigint;
+    prepare: bigint;
+};
+export type ReadRevision = typeof constants.START | typeof constants.END | bigint;
+export type ReadPosition = typeof constants.START | typeof constants.END | Position;
+/**
+ * Constants used for expected version control. The use of expected version can be a bit tricky especially when
+ * discussing assurances given by the KurrentDB server.
+ *
+ * The KurrentDB server will assure idempotency for all operations using any value in ExpectedVersion except
+ * {@link ANY}. When using {@link ANY}., the KurrentDB server will do its best to assure
+ * idempotency but will not guarantee idempotency.
+ */
+export type StreamState = typeof constants.ANY
+/**
+ * The stream being written to should not yet exist. If it does exist, treats that as a concurrency problem.
+ */
+ | typeof constants.NO_STREAM
+/**
+ * States that the last event written to the stream should have an event number matching your expected value.
+ */
+ | bigint;
+export type AppendStreamState = 
+/**
+ * The stream should exist. If it or a metadata stream does not exist, treats that as a concurrency problem.
+ */
+typeof constants.STREAM_EXISTS
+/**
+ * @see {@link StreamState}.
+ */
+ | StreamState;
+export type CurrentStreamState = 
+/**
+ * The stream being written to does not yet exist.
+ */
+typeof constants.NO_STREAM
+/**
+ * The current event number of the last event written to the stream.
+ */
+ | bigint;
+/**
+ * Represents the direction of read operation (both from '$all' and a regular stream).
+ */
+export type Direction = typeof constants.FORWARDS | typeof constants.BACKWARDS;
+export interface AppendResult {
+    /**
+     * If the append was successful. Only relevent if `throwOnAppendFailure` is set to false.
+     */
+    success: boolean;
+    /**
+     * The current revision of the stream, to be passed as the `expectedRevision` in the next call.
+     */
+    nextExpectedRevision: bigint;
+    /**
+     * The logical record position in the KurrentDB transaction file.
+     */
+    position?: Position;
+}
+export type ProjectionStatus = typeof constants.CREATING | typeof constants.LOADING | typeof constants.LOADED | typeof constants.PREPARING | typeof constants.PREPARED | typeof constants.STARTING | typeof constants.LOADING_STOPPED | typeof constants.RUNNING | typeof constants.STOPPING | typeof constants.ABORTING | typeof constants.STOPPED | typeof constants.COMPLETED | typeof constants.ABORTED | typeof constants.FAULTED | typeof constants.DELETING;
+export type ProcessingStatus = typeof constants.PAUSED | typeof constants.WRITING_RESULTS | typeof constants.STOPPED | "";
+/**
+ * Provides the details for a projection.
+ */
+export interface ProjectionDetails {
+    /**
+     * The CoreProcessingTime.
+     */
+    coreProcessingTime: bigint;
+    /**
+     * The projection version.
+     */
+    version: bigint;
+    /**
+     * The Epoch.
+     */
+    epoch: bigint;
+    /**
+     * The projection EffectiveName.
+     */
+    effectiveName: string;
+    /**
+     * The projection WritesInProgress.
+     */
+    writesInProgress: number;
+    /**
+     * The projection ReadsInProgress.
+     */
+    readsInProgress: number;
+    /**
+     * The projection PartitionsCached.
+     */
+    partitionsCached: number;
+    /**
+     * The raw status of the projection.
+     * Split into {@link projectionStatus} and {@link processingStatus} for convenience.
+     */
+    status: string;
+    /**
+     * The current status of the projection.
+     */
+    projectionStatus: ProjectionStatus;
+    /**
+     * The current status of the projection.
+     */
+    processingStatus: ProcessingStatus;
+    /**
+     * The projection StateReason.
+     */
+    stateReason: string;
+    /**
+     * The projection Name.
+     */
+    name: string;
+    /**
+     * The projection Position.
+     */
+    position: string;
+    /**
+     * The projection Progress.
+     */
+    progress: number;
+    /**
+     * LastCheckpoint.
+     */
+    lastCheckpoint: string;
+    /**
+     * The projection EventsProcessedAfterRestart.
+     */
+    eventsProcessedAfterRestart: bigint;
+    /**
+     * The projection CheckpointStatus.
+     */
+    checkpointStatus: string;
+    /**
+     * The projection BufferedEvents.
+     */
+    bufferedEvents: bigint;
+    /**
+     * The projection WritePendingEventsBeforeCheckpoint.
+     */
+    writePendingEventsBeforeCheckpoint: number;
+    /**
+     * The projection WritePendingEventsAfterCheckpoint.
+     */
+    writePendingEventsAfterCheckpoint: number;
+}
+export interface DeleteResult {
+    position?: Position;
+}
+export type ConsumerStrategy = typeof constants.DISPATCH_TO_SINGLE | typeof constants.ROUND_ROBIN | typeof constants.PINNED;
+export type PersistentAction = typeof constants.PARK | typeof constants.RETRY | typeof constants.SKIP | typeof constants.STOP;
+export type NodePreference = typeof constants.RANDOM | typeof constants.FOLLOWER | typeof constants.LEADER | typeof constants.READ_ONLY_REPLICA;
+export interface EndPoint {
+    address: string;
+    port: number;
+}
+export interface MemberInfo {
+    instanceId?: string;
+    timeStamp: number;
+    state: VNodeState;
+    isAlive: boolean;
+    httpEndpoint?: EndPoint;
+}
+export type VerifyOptions = Parameters<typeof ChannelCredentials.createSsl>[3];
+export type GRPCClientConstructor<T extends GRPCClient> = new (address: string, credentials: ChannelCredentials, options?: Partial<GRPCClientOptions>) => T;
+export type FilterOn = typeof constants.EVENT_TYPE | typeof constants.STREAM_NAME;
+export interface FilterBase {
+    /**
+     * What to filter on.
+     */
+    filterOn: FilterOn;
+    /**
+     * Sets how often the checkpointReached callback is called.
+     * Must be greater than 0.
+     */
+    checkpointInterval: number;
+    /**
+     * A callback invoked and await when a checkpoint is reached.
+     * Set the checkpointInterval to define how often this method is called.
+     */
+    checkpointReached?: (subscription: AllStreamSubscription, position: Position) => Promise<void> | void;
+    /**
+     * The maximum number of events that are filtered out before the page is returned
+     * Must be greater than 0, if supplied.
+     */
+    maxSearchWindow?: number;
+}
+export interface RegexFilter extends FilterBase {
+    /**
+     * A regex to filter by.
+     */
+    regex: string;
+}
+export interface PrefixesFilter extends FilterBase {
+    /**
+     * A list of prefixes to filter on.
+     */
+    prefixes: string[];
+}
+export type Filter = RegexFilter | PrefixesFilter;
+export interface Credentials {
+    username: string;
+    password: string;
+}
+export interface Certificate {
+    userCertFile: Buffer;
+    userKeyFile: Buffer;
+}
+export interface StreamingRead<E> extends Readable {
+    cancel(): Promise<void>;
+    addListener(event: "close", listener: () => void): this;
+    addListener(event: "data", listener: (event: E) => void): this;
+    addListener(event: "end", listener: () => void): this;
+    addListener(event: "readable", listener: () => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    on(event: "close", listener: () => void): this;
+    on(event: "data", listener: (event: E) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "readable", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    once(event: "close", listener: () => void): this;
+    once(event: "data", listener: (event: E) => void): this;
+    once(event: "end", listener: () => void): this;
+    once(event: "readable", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    prependListener(event: "close", listener: () => void): this;
+    prependListener(event: "data", listener: (event: E) => void): this;
+    prependListener(event: "end", listener: () => void): this;
+    prependListener(event: "readable", listener: () => void): this;
+    prependListener(event: "error", listener: (err: Error) => void): this;
+    prependListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    prependOnceListener(event: "close", listener: () => void): this;
+    prependOnceListener(event: "data", listener: (event: E) => void): this;
+    prependOnceListener(event: "end", listener: () => void): this;
+    prependOnceListener(event: "readable", listener: () => void): this;
+    prependOnceListener(event: "error", listener: (err: Error) => void): this;
+    prependOnceListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    removeListener(event: "close", listener: () => void): this;
+    removeListener(event: "data", listener: (event: E) => void): this;
+    removeListener(event: "end", listener: () => void): this;
+    removeListener(event: "error", listener: (err: Error) => void): this;
+    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<E>;
+}
+export interface ReadableSubscription<E> extends Readable {
+    id?: string;
+    unsubscribe(): Promise<void>;
+    addListener(event: "close", listener: () => void): this;
+    addListener(event: "data", listener: (event: E) => void): this;
+    addListener(event: "end", listener: () => void): this;
+    addListener(event: "readable", listener: () => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "confirmation", listener: () => void): this;
+    addListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    on(event: "close", listener: () => void): this;
+    on(event: "data", listener: (event: E) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "readable", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: "confirmation", listener: () => void): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    once(event: "close", listener: () => void): this;
+    once(event: "data", listener: (event: E) => void): this;
+    once(event: "end", listener: () => void): this;
+    once(event: "readable", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: "confirmation", listener: () => void): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    prependListener(event: "close", listener: () => void): this;
+    prependListener(event: "data", listener: (event: E) => void): this;
+    prependListener(event: "end", listener: () => void): this;
+    prependListener(event: "readable", listener: () => void): this;
+    prependListener(event: "error", listener: (err: Error) => void): this;
+    prependListener(event: "confirmation", listener: () => void): this;
+    prependListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    prependOnceListener(event: "close", listener: () => void): this;
+    prependOnceListener(event: "data", listener: (event: E) => void): this;
+    prependOnceListener(event: "end", listener: () => void): this;
+    prependOnceListener(event: "readable", listener: () => void): this;
+    prependOnceListener(event: "error", listener: (err: Error) => void): this;
+    prependOnceListener(event: "confirmation", listener: () => void): this;
+    prependOnceListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    removeListener(event: "close", listener: () => void): this;
+    removeListener(event: "data", listener: (event: E) => void): this;
+    removeListener(event: "end", listener: () => void): this;
+    removeListener(event: "readable", listener: () => void): this;
+    removeListener(event: "error", listener: (err: Error) => void): this;
+    removeListener(event: "confirmation", listener: () => void): this;
+    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<E>;
+}
+export interface PersistentSubscriptionBase<E> extends ReadableSubscription<E> {
+    /**
+     * Acknowledge events as handled.
+     */
+    ack(...events: ResolvedEvent[]): Promise<void>;
+    /**
+     * "Not Acknowledge" the event.
+     */
+    nack(action: PersistentAction, reason: string, ...events: ResolvedEvent[]): Promise<void>;
+}
+export interface CatchupSubscription {
+    addListener(event: "caughtUp", listener: () => void): this;
+    addListener(event: "fellBehind", listener: () => void): this;
+    on(event: "caughtUp", listener: () => void): this;
+    on(event: "fellBehind", listener: () => void): this;
+    once(event: "caughtUp", listener: () => void): this;
+    once(event: "fellBehind", listener: () => void): this;
+    prependListener(event: "caughtUp", listener: () => void): this;
+    prependListener(event: "fellBehind", listener: () => void): this;
+    prependOnceListener(event: "caughtUp", listener: () => void): this;
+    prependOnceListener(event: "fellBehind", listener: () => void): this;
+    removeListener(event: "caughtUp", listener: () => void): this;
+    removeListener(event: "fellBehind", listener: () => void): this;
+}
+export type PersistentSubscriptionToStream<E extends EventType = EventType> = PersistentSubscriptionBase<PersistentSubscriptionToStreamResolvedEvent<E>>;
+export type PersistentSubscriptionToAll = PersistentSubscriptionBase<PersistentSubscriptionToAllResolvedEvent>;
+export type StreamSubscription<E extends EventType = EventType> = ReadableSubscription<ResolvedEvent<E>> & CatchupSubscription;
+export type AllStreamSubscription = ReadableSubscription<AllStreamResolvedEvent> & CatchupSubscription;
+export { VNodeState };
+export * from "./events";

package/dist/types/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VNodeState = void 0;
+const gossip_pb_1 = require("../../generated/gossip_pb");
+var VNodeState = gossip_pb_1.MemberInfo.VNodeState;
+exports.VNodeState = VNodeState;
+__exportStar(require("./events"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAOA,yDAAyE;AACzE,IAAO,UAAU,GAAG,sBAAc,CAAC,UAAU,CAAC;AA0frC,gCAAU;AACnB,2CAAyB"}

package/dist/utils/CommandError.d.ts

@@ -0,0 +1,174 @@
+import { status as StatusCode, ServiceError } from "@grpc/grpc-js";
+import type { WrongExpectedVersion } from "../../generated/shared_pb";
+import type { CurrentStreamState, EndPoint, AppendStreamState } from "../types";
+export declare enum ErrorType {
+    TIMEOUT = "timeout",
+    DEADLINE_EXCEEDED = "deadline-exceeded",
+    UNAVAILABLE = "unavailable",
+    CANCELLED = "cancelled",
+    UNKNOWN = "unknown",
+    NOT_LEADER = "not-leader",
+    STREAM_NOT_FOUND = "stream-not-found",
+    NO_STREAM = "no-stream",
+    NOT_FOUND = "not-found",
+    ACCESS_DENIED = "access-denied",
+    INVALID_ARGUMENT = "invalid-argument",
+    INVALID_TRANSACTION = "invalid-transaction",
+    STREAM_DELETED = "stream-deleted",
+    SCAVENGE_NOT_FOUND = "scavenge-not-found",
+    WRONG_EXPECTED_VERSION = "wrong-expected-version",
+    MAXIMUM_APPEND_SIZE_EXCEEDED = "maximum-append-size-exceeded",
+    MISSING_REQUIRED_METADATA_PROPERTY = "missing-required-metadata-property",
+    PERSISTENT_SUBSCRIPTION_FAILED = "persistent-subscription-failed",
+    PERSISTENT_SUBSCRIPTION_DOES_NOT_EXIST = "persistent-subscription-does-not-exist",
+    PERSISTENT_SUBSCRIPTION_EXISTS = "persistent-subscription-exists",
+    PERSISTENT_SUBSCRIPTION_DROPPED = "persistent-subscription-dropped",
+    MAXIMUM_SUBSCRIBERS_REACHED = "maximum-subscribers-reached",
+    USER_NOT_FOUND = "user-not-found",
+    USER_CONFLICT = "user-conflict",
+    UNSUPPORTED = "unsupported"
+}
+declare abstract class CommandErrorBase extends Error {
+    abstract readonly type: ErrorType;
+    code?: StatusCode;
+    message: string;
+    _raw?: ServiceError;
+    constructor(error?: ServiceError, message?: string);
+}
+export declare class TimeoutError extends CommandErrorBase {
+    type: ErrorType.TIMEOUT;
+}
+export declare class DeadlineExceededError extends CommandErrorBase {
+    type: ErrorType.DEADLINE_EXCEEDED;
+}
+export declare class UnavailableError extends CommandErrorBase {
+    type: ErrorType.UNAVAILABLE;
+}
+export declare class CancelledError extends CommandErrorBase {
+    type: ErrorType.CANCELLED;
+}
+export declare class NotFoundError extends CommandErrorBase {
+    type: ErrorType.NOT_FOUND;
+}
+export declare class UnknownError extends CommandErrorBase {
+    type: ErrorType.UNKNOWN;
+}
+export declare class NotLeaderError extends CommandErrorBase {
+    type: ErrorType.NOT_LEADER;
+    leader: EndPoint;
+    constructor(error: ServiceError);
+}
+export declare class StreamNotFoundError extends CommandErrorBase {
+    type: ErrorType.STREAM_NOT_FOUND;
+    streamName: string;
+    static nameToString: (error?: ServiceError, streamName?: string | Uint8Array) => string;
+    constructor(error?: ServiceError, streamName?: string | Uint8Array);
+}
+export declare class NoStreamError extends CommandErrorBase {
+    type: ErrorType.NO_STREAM;
+}
+export declare class AccessDeniedError extends CommandErrorBase {
+    type: ErrorType.ACCESS_DENIED;
+}
+export declare class InvalidTransactionError extends CommandErrorBase {
+    type: ErrorType.INVALID_TRANSACTION;
+}
+export declare class StreamDeletedError extends CommandErrorBase {
+    type: ErrorType.STREAM_DELETED;
+    streamName: string;
+    static fromStreamName: (streamName: string) => StreamDeletedError;
+    constructor(error: ServiceError);
+    constructor(error: undefined, streamName: string);
+}
+export declare class ScavengeNotFoundError extends CommandErrorBase {
+    type: ErrorType.SCAVENGE_NOT_FOUND;
+    scavengeId: string;
+    constructor(error: ServiceError);
+}
+interface WrongExpectedVersionDetails {
+    streamName: string;
+    expected: AppendStreamState;
+    current: CurrentStreamState;
+}
+export declare class WrongExpectedVersionError extends CommandErrorBase {
+    type: ErrorType.WRONG_EXPECTED_VERSION;
+    streamName: string;
+    expectedState: AppendStreamState;
+    actualState: CurrentStreamState;
+    static fromWrongExpectedVersion: (details: WrongExpectedVersion, streamName: string) => WrongExpectedVersionError;
+    constructor(error: ServiceError);
+    constructor(error: undefined, versions: WrongExpectedVersionDetails);
+}
+export declare class MaxAppendSizeExceededError extends CommandErrorBase {
+    type: ErrorType.MAXIMUM_APPEND_SIZE_EXCEEDED;
+    maxAppendSize: number;
+    static fromMaxAppendSize: (maxAppendSize: number) => MaxAppendSizeExceededError;
+    constructor(error: ServiceError);
+    constructor(error: undefined, maxAppendSize: number);
+}
+export declare class RequiredMetadataPropertyMissingError extends CommandErrorBase {
+    type: ErrorType.MISSING_REQUIRED_METADATA_PROPERTY;
+    requiredMetadataProperties: string[];
+    constructor(error: ServiceError);
+}
+export declare class PersistentSubscriptionFailedError extends CommandErrorBase {
+    type: ErrorType.PERSISTENT_SUBSCRIPTION_FAILED;
+    streamName: string;
+    groupName: string;
+    reason: string;
+    constructor(error: ServiceError);
+}
+interface PersistentSubscriptionDoesNotExistMeta {
+    streamName: string;
+    groupName?: string;
+}
+export declare class PersistentSubscriptionDoesNotExistError extends CommandErrorBase {
+    type: ErrorType.PERSISTENT_SUBSCRIPTION_DOES_NOT_EXIST;
+    streamName: string;
+    groupName: string;
+    constructor(error: ServiceError);
+    constructor(error: undefined, metadata: PersistentSubscriptionDoesNotExistMeta);
+}
+export declare class PersistentSubscriptionExistsError extends CommandErrorBase {
+    type: ErrorType.PERSISTENT_SUBSCRIPTION_EXISTS;
+    streamName: string;
+    groupName: string;
+    constructor(error: ServiceError);
+}
+export declare class PersistentSubscriptionMaximumSubscribersReachedError extends CommandErrorBase {
+    type: ErrorType.MAXIMUM_SUBSCRIBERS_REACHED;
+    streamName: string;
+    groupName: string;
+    constructor(error: ServiceError);
+}
+export declare class PersistentSubscriptionDroppedError extends CommandErrorBase {
+    type: ErrorType.PERSISTENT_SUBSCRIPTION_DROPPED;
+    streamName: string;
+    groupName: string;
+    constructor(error: ServiceError);
+}
+export declare class LoginNotFoundError extends CommandErrorBase {
+    type: ErrorType.USER_NOT_FOUND;
+    LoginName: string;
+    constructor(error: ServiceError);
+}
+export declare class LoginConflictError extends CommandErrorBase {
+    type: ErrorType.USER_CONFLICT;
+    LoginName: string;
+    constructor(error: ServiceError);
+}
+export declare class UnsupportedError extends CommandErrorBase {
+    type: ErrorType.UNSUPPORTED;
+    feature: string;
+    minimumVersion: string;
+    constructor(feature: string, minimumVersion: string);
+}
+export declare class InvalidArgumentError extends CommandErrorBase {
+    type: ErrorType.INVALID_ARGUMENT;
+    errorMessage: string;
+    constructor(error: string);
+}
+export type CommandError = NotLeaderError | StreamNotFoundError | NoStreamError | AccessDeniedError | InvalidArgumentError | InvalidTransactionError | StreamDeletedError | ScavengeNotFoundError | WrongExpectedVersionError | MaxAppendSizeExceededError | RequiredMetadataPropertyMissingError | PersistentSubscriptionFailedError | PersistentSubscriptionDoesNotExistError | PersistentSubscriptionExistsError | PersistentSubscriptionDroppedError | PersistentSubscriptionMaximumSubscribersReachedError | LoginNotFoundError | LoginConflictError | TimeoutError | DeadlineExceededError | UnavailableError | CancelledError | UnknownError | UnsupportedError;
+export declare const convertToCommandError: (error: Error) => CommandError | Error;
+export declare const isCommandError: (error: Error) => error is CommandError;
+export {};