@dxos/compute 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

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

@@ -0,0 +1,75 @@
+import * as Schema from 'effect/Schema';
+import { Obj, Ref } from '@dxos/echo';
+export declare const EmailEvent: Schema.Struct<{
+    from: typeof Schema.String;
+    to: typeof Schema.String;
+    subject: typeof Schema.String;
+    created: typeof Schema.String;
+    body: typeof Schema.String;
+}>;
+export type EmailEvent = Schema.Schema.Type<typeof EmailEvent>;
+export declare const QueueEvent: Schema.Struct<{
+    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
+    item: typeof Schema.Any;
+    cursor: typeof Schema.String;
+}>;
+export type QueueEvent = Schema.Schema.Type<typeof QueueEvent>;
+export declare const SubscriptionEvent: Schema.Struct<{
+    /**
+     * Type of the mutation.
+     */
+    type: typeof Schema.String;
+    /**
+     * Reference to the object that was changed or created.
+     */
+    subject: Ref.RefSchema<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    /**
+     * @deprecated
+     */
+    changedObjectId: Schema.optional<typeof Schema.String>;
+}>;
+export type SubscriptionEvent = Schema.Schema.Type<typeof SubscriptionEvent>;
+export declare const TimerEvent: Schema.Struct<{
+    tick: typeof Schema.Number;
+}>;
+export type TimerEvent = Schema.Schema.Type<typeof TimerEvent>;
+export declare const WebhookEvent: Schema.Struct<{
+    url: typeof Schema.String;
+    method: Schema.Literal<["GET", "POST"]>;
+    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    bodyText: typeof Schema.String;
+}>;
+export type WebhookEvent = Schema.Schema.Type<typeof WebhookEvent>;
+export declare const TriggerEvent: Schema.Union<[Schema.Struct<{
+    from: typeof Schema.String;
+    to: typeof Schema.String;
+    subject: typeof Schema.String;
+    created: typeof Schema.String;
+    body: typeof Schema.String;
+}>, Schema.Struct<{
+    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
+    item: typeof Schema.Any;
+    cursor: typeof Schema.String;
+}>, Schema.Struct<{
+    /**
+     * Type of the mutation.
+     */
+    type: typeof Schema.String;
+    /**
+     * Reference to the object that was changed or created.
+     */
+    subject: Ref.RefSchema<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    /**
+     * @deprecated
+     */
+    changedObjectId: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    tick: typeof Schema.Number;
+}>, Schema.Struct<{
+    url: typeof Schema.String;
+    method: Schema.Literal<["GET", "POST"]>;
+    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    bodyText: typeof Schema.String;
+}>]>;
+export type TriggerEvent = Schema.Schema.Type<typeof TriggerEvent>;
+//# sourceMappingURL=TriggerEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TriggerEvent.d.ts","sourceRoot":"","sources":["../../../src/TriggerEvent.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAO,GAAG,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAQ3C,eAAO,MAAM,UAAU;;;;;;EAMrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;EAIrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;;IAIH;;OAEG;;IAGH;;OAEG;;EAEH,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE7E,eAAO,MAAM,UAAU;;EAAyC,CAAC;AACjE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,YAAY;;;;;EAKvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC;AAEnE,eAAO,MAAM,YAAY;;;;;;;;;;;IA7BvB;;OAEG;;IAIH;;OAEG;;IAGH;;OAEG;;;;;;;;;IAgBwG,CAAC;AAC9G,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC"}

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

@@ -0,0 +1,239 @@
+import { BaseError, type BaseErrorOptions } from '@dxos/errors';
+declare const InvokerNotInitializedError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvokerNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvokerNotInitializedError";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvokerNotInitializedError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvokerNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvokerNotInitializedError";
+    };
+    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 InvokerNotInitializedError extends InvokerNotInitializedError_base {
+    constructor();
+}
+declare const NoHandlerError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "NoHandlerError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "NoHandlerError";
+    };
+    isError(error: unknown): error is Error;
+    name: "NoHandlerError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "NoHandlerError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "NoHandlerError";
+    };
+    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 NoHandlerError extends NoHandlerError_base {
+    constructor(operationKey: string);
+}
+declare const ServiceNotAvailableError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "ServiceNotAvailable";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ServiceNotAvailable";
+    };
+    isError(error: unknown): error is Error;
+    name: "ServiceNotAvailable";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "ServiceNotAvailable";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ServiceNotAvailable";
+    };
+    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 ServiceNotAvailableError extends ServiceNotAvailableError_base {
+    constructor(service: string, options?: Omit<BaseErrorOptions, 'context'>);
+}
+declare const FunctionNotFoundError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionNotFound";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionNotFound";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionNotFound";
+    };
+    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 FunctionNotFoundError extends FunctionNotFoundError_base {
+    constructor(functionKey: string, options?: Omit<BaseErrorOptions, 'context'>);
+}
+declare const FunctionError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionError";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionError";
+    };
+    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 FunctionError extends FunctionError_base {
+}
+declare const InvalidOperationInputError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationInput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationInput";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidOperationInput";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationInput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationInput";
+    };
+    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 InvalidOperationInputError extends InvalidOperationInputError_base {
+}
+declare const InvalidOperationOutputError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationOutput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationOutput";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidOperationOutput";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationOutput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationOutput";
+    };
+    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 InvalidOperationOutputError extends InvalidOperationOutputError_base {
+}
+declare const TriggerStateNotFoundError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "TriggerStateNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TriggerStateNotFound";
+    };
+    isError(error: unknown): error is Error;
+    name: "TriggerStateNotFound";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "TriggerStateNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TriggerStateNotFound";
+    };
+    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 TriggerStateNotFoundError extends TriggerStateNotFoundError_base {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIhE,qBAAa,0BAA2B,SAAQ,+BAG/C;IACC,cAEC;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,cAAe,SAAQ,mBAAsE;IACxG,YAAY,YAAY,EAAE,MAAM,EAE/B;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAID,qBAAa,wBAAyB,SAAQ,6BAAgE;IAC5G,YAAY,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,EAEvE;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,qBAAsB,SAAQ,0BAA0D;IACnG,YAAY,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,EAE3E;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,aAAc,SAAQ,kBAA8D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,0BAA2B,SAAQ,+BAG/C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,2BAA4B,SAAQ,gCAGhD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,yBAA0B,SAAQ,8BAAmE;CAAG"}

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

@@ -1,6 +1,16 @@
-export * from './compute-graph';
-export * from './compute-graph-registry';
-export * from './compute-node';
-export * from './functions';
-export * from './types';
+export * as Blueprint from './Blueprint';
+export * as Credential from './Credential';
+export * from './errors';
+export * as Operation from './Operation';
+export * as OperationHandlerSet from './OperationHandlerSet';
+export * as OperationRegistry from './OperationRegistry';
+export * as Process from './Process';
+export * as Routine from './Routine';
+export * as Script from './Script';
+export * as ServiceResolver from './ServiceResolver';
+export * as StorageService from './StorageService';
+export * as Template from './Template';
+export * as Trace from './Trace';
+export * as Trigger from './Trigger';
+export * as TriggerEvent from './TriggerEvent';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AA+BA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,cAAc,UAAU,CAAC;AACzB,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,mBAAmB,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,iBAAiB,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,eAAe,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,11 @@
+import * as Operation from '../Operation';
+export declare const Fibonacci: Operation.Definition<{
+    readonly iterations?: number | undefined;
+}, {
+    readonly result: string;
+}, never>;
+export declare const Reply: Operation.Definition<any, any, never>;
+export declare const Sleep: Operation.Definition<{
+    readonly duration?: number | undefined;
+}, void, never>;
+//# sourceMappingURL=definitions.d.ts.map

package/dist/types/src/testing/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../../src/testing/definitions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,SAAS;;;;SAepB,CAAC;AAEH,eAAO,MAAM,KAAK,uCAQhB,CAAC;AAEH,eAAO,MAAM,KAAK;;eAahB,CAAC"}

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

@@ -0,0 +1,8 @@
+import * as Operation from '../Operation';
+declare const _default: Operation.WithHandler<Operation.Definition<{
+    readonly iterations?: number | undefined;
+}, {
+    readonly result: string;
+}, never>>;
+export default _default;
+//# sourceMappingURL=fib.d.ts.map

package/dist/types/src/testing/fib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fib.d.ts","sourceRoot":"","sources":["../../../../src/testing/fib.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC"}

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

@@ -1,4 +1,7 @@
-export * from './test-builder';
-export * from './test-plugin';
-export * from './util';
+import * as OperationHandlerSet from '../OperationHandlerSet';
+export { Fibonacci, Reply, Sleep } from './definitions';
+export { default as FibonacciHandler } from './fib';
+export { default as ReplyHandler } from './reply';
+export { default as SleepHandler } from './sleep';
+export declare const ExampleHandlers: OperationHandlerSet.OperationHandlerSet;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/src/testing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,mBAAmB,MAAM,wBAAwB,CAAC;AAE9D,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,OAAO,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD,eAAO,MAAM,eAAe,yCAI3B,CAAC"}

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

@@ -0,0 +1,4 @@
+import * as Operation from '../Operation';
+declare const _default: Operation.WithHandler<Operation.Definition<any, any, never>>;
+export default _default;
+//# sourceMappingURL=reply.d.ts.map

package/dist/types/src/testing/reply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply.d.ts","sourceRoot":"","sources":["../../../../src/testing/reply.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC"}

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

@@ -0,0 +1,6 @@
+import * as Operation from '../Operation';
+declare const _default: Operation.WithHandler<Operation.Definition<{
+    readonly duration?: number | undefined;
+}, void, never>>;
+export default _default;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/types/src/testing/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../../src/testing/sleep.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=umbrella.test.d.ts.map

package/dist/types/src/umbrella.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"umbrella.test.d.ts","sourceRoot":"","sources":["../../../src/umbrella.test.ts"],"names":[],"mappings":""}