@dxos/errors 0.8.4-main.f5c0578 → 0.8.4-main.fbb7a13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. package/dist/lib/browser/index.mjs +50 -40
  2. package/dist/lib/browser/index.mjs.map +3 -3
  3. package/dist/lib/browser/meta.json +1 -1
  4. package/dist/lib/node-esm/index.mjs +50 -40
  5. package/dist/lib/node-esm/index.mjs.map +3 -3
  6. package/dist/lib/node-esm/meta.json +1 -1
  7. package/dist/types/src/base.d.ts +33 -36
  8. package/dist/types/src/base.d.ts.map +1 -1
  9. package/dist/types/src/errors.d.ts +235 -228
  10. package/dist/types/src/errors.d.ts.map +1 -1
  11. package/dist/types/tsconfig.tsbuildinfo +1 -1
  12. package/package.json +6 -2
  13. package/src/base.ts +40 -37
  14. package/src/errors.test.ts +25 -5
  15. package/src/errors.ts +8 -6
package/dist/types/src/errors.d.ts CHANGED
@@ -1,55 +1,47 @@
1
1
  import { BaseError } from './base';
2
- declare const TimeoutError_base: {
3
- new (message: string, options?: import("./base").BaseErrorOptions): {
4
- #code: "TIMEOUT";
5
- #context: Record<string, unknown>;
6
- get name(): "TIMEOUT";
7
- get code(): "TIMEOUT";
8
- get _tag(): "TIMEOUT";
9
- get context(): Record<string, unknown>;
10
- message: string;
2
+ declare const ApiError_base: {
3
+ new (options?: import("./base").BaseErrorOptions): {
4
+ name: "ApiError";
5
+ context: Record<string, unknown>;
6
+ get message(): string;
7
+ get _tag(): "ApiError";
11
8
  stack?: string;
12
9
  cause?: unknown;
13
10
  };
14
- code: "TIMEOUT";
11
+ name: "ApiError";
15
12
  is(error: unknown): error is BaseError;
16
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
17
- #code: "TIMEOUT";
18
- #context: Record<string, unknown>;
19
- get name(): "TIMEOUT";
20
- get code(): "TIMEOUT";
21
- get _tag(): "TIMEOUT";
22
- get context(): Record<string, unknown>;
23
- message: string;
13
+ wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
14
+ ifTypeDiffers?: boolean;
15
+ }) | undefined): (error: unknown) => {
16
+ name: "ApiError";
17
+ context: Record<string, unknown>;
18
+ get message(): string;
19
+ get _tag(): "ApiError";
24
20
  stack?: string;
25
21
  cause?: unknown;
26
22
  };
27
- extend<Code extends string>(code: Code): {
28
- new (message: string, options?: import("./base").BaseErrorOptions): {
29
- #code: Code;
30
- #context: Record<string, unknown>;
31
- get name(): Code;
32
- get code(): Code;
33
- get _tag(): Code;
34
- get context(): Record<string, unknown>;
35
- message: string;
23
+ extend<Name extends string = string>(name: Name, message?: string): {
24
+ new (options?: import("./base").BaseErrorOptions): {
25
+ name: Name;
26
+ context: Record<string, unknown>;
27
+ get message(): string;
28
+ get _tag(): Name;
36
29
  stack?: string;
37
30
  cause?: unknown;
38
31
  };
39
- code: Code;
32
+ name: Name;
40
33
  is(error: unknown): error is BaseError;
41
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
42
- #code: Code;
43
- #context: Record<string, unknown>;
44
- get name(): Code;
45
- get code(): Code;
46
- get _tag(): Code;
47
- get context(): Record<string, unknown>;
48
- message: string;
34
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
35
+ ifTypeDiffers?: boolean;
36
+ }): (error: unknown) => {
37
+ name: Name;
38
+ context: Record<string, unknown>;
39
+ get message(): string;
40
+ get _tag(): Name;
49
41
  stack?: string;
50
42
  cause?: unknown;
51
43
  };
52
- extend<Code extends string>(code: Code): /*elided*/ any;
44
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
53
45
  isError(error: unknown): error is Error;
54
46
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
55
47
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -60,59 +52,51 @@ declare const TimeoutError_base: {
60
52
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
61
53
  stackTraceLimit: number;
62
54
  };
63
- export declare class TimeoutError extends TimeoutError_base {
55
+ export declare class ApiError extends ApiError_base {
64
56
  }
65
- declare const AbortedError_base: {
66
- new (message: string, options?: import("./base").BaseErrorOptions): {
67
- #code: "ABORTED";
68
- #context: Record<string, unknown>;
69
- get name(): "ABORTED";
70
- get code(): "ABORTED";
71
- get _tag(): "ABORTED";
72
- get context(): Record<string, unknown>;
73
- message: string;
57
+ declare const SystemError_base: {
58
+ new (options?: import("./base").BaseErrorOptions): {
59
+ name: "SystemError";
60
+ context: Record<string, unknown>;
61
+ get message(): string;
62
+ get _tag(): "SystemError";
74
63
  stack?: string;
75
64
  cause?: unknown;
76
65
  };
77
- code: "ABORTED";
66
+ name: "SystemError";
78
67
  is(error: unknown): error is BaseError;
79
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
80
- #code: "ABORTED";
81
- #context: Record<string, unknown>;
82
- get name(): "ABORTED";
83
- get code(): "ABORTED";
84
- get _tag(): "ABORTED";
85
- get context(): Record<string, unknown>;
86
- message: string;
68
+ wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
69
+ ifTypeDiffers?: boolean;
70
+ }) | undefined): (error: unknown) => {
71
+ name: "SystemError";
72
+ context: Record<string, unknown>;
73
+ get message(): string;
74
+ get _tag(): "SystemError";
87
75
  stack?: string;
88
76
  cause?: unknown;
89
77
  };
90
- extend<Code extends string>(code: Code): {
91
- new (message: string, options?: import("./base").BaseErrorOptions): {
92
- #code: Code;
93
- #context: Record<string, unknown>;
94
- get name(): Code;
95
- get code(): Code;
96
- get _tag(): Code;
97
- get context(): Record<string, unknown>;
98
- message: string;
78
+ extend<Name extends string = string>(name: Name, message?: string): {
79
+ new (options?: import("./base").BaseErrorOptions): {
80
+ name: Name;
81
+ context: Record<string, unknown>;
82
+ get message(): string;
83
+ get _tag(): Name;
99
84
  stack?: string;
100
85
  cause?: unknown;
101
86
  };
102
- code: Code;
87
+ name: Name;
103
88
  is(error: unknown): error is BaseError;
104
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
105
- #code: Code;
106
- #context: Record<string, unknown>;
107
- get name(): Code;
108
- get code(): Code;
109
- get _tag(): Code;
110
- get context(): Record<string, unknown>;
111
- message: string;
89
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
90
+ ifTypeDiffers?: boolean;
91
+ }): (error: unknown) => {
92
+ name: Name;
93
+ context: Record<string, unknown>;
94
+ get message(): string;
95
+ get _tag(): Name;
112
96
  stack?: string;
113
97
  cause?: unknown;
114
98
  };
115
- extend<Code extends string>(code: Code): /*elided*/ any;
99
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
116
100
  isError(error: unknown): error is Error;
117
101
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
118
102
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -123,59 +107,51 @@ declare const AbortedError_base: {
123
107
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
124
108
  stackTraceLimit: number;
125
109
  };
126
- export declare class AbortedError extends AbortedError_base {
110
+ export declare class SystemError extends SystemError_base {
127
111
  }
128
- declare const UnimplementedError_base: {
129
- new (message: string, options?: import("./base").BaseErrorOptions): {
130
- #code: "UNIMPLEMENTED";
131
- #context: Record<string, unknown>;
132
- get name(): "UNIMPLEMENTED";
133
- get code(): "UNIMPLEMENTED";
134
- get _tag(): "UNIMPLEMENTED";
135
- get context(): Record<string, unknown>;
136
- message: string;
112
+ declare const InternalError_base: {
113
+ new (options?: import("./base").BaseErrorOptions): {
114
+ name: "InternalError";
115
+ context: Record<string, unknown>;
116
+ get message(): string;
117
+ get _tag(): "InternalError";
137
118
  stack?: string;
138
119
  cause?: unknown;
139
120
  };
140
- code: "UNIMPLEMENTED";
121
+ name: "InternalError";
141
122
  is(error: unknown): error is BaseError;
142
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
143
- #code: "UNIMPLEMENTED";
144
- #context: Record<string, unknown>;
145
- get name(): "UNIMPLEMENTED";
146
- get code(): "UNIMPLEMENTED";
147
- get _tag(): "UNIMPLEMENTED";
148
- get context(): Record<string, unknown>;
149
- message: string;
123
+ wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
124
+ ifTypeDiffers?: boolean;
125
+ }) | undefined): (error: unknown) => {
126
+ name: "InternalError";
127
+ context: Record<string, unknown>;
128
+ get message(): string;
129
+ get _tag(): "InternalError";
150
130
  stack?: string;
151
131
  cause?: unknown;
152
132
  };
153
- extend<Code extends string>(code: Code): {
154
- new (message: string, options?: import("./base").BaseErrorOptions): {
155
- #code: Code;
156
- #context: Record<string, unknown>;
157
- get name(): Code;
158
- get code(): Code;
159
- get _tag(): Code;
160
- get context(): Record<string, unknown>;
161
- message: string;
133
+ extend<Name extends string = string>(name: Name, message?: string): {
134
+ new (options?: import("./base").BaseErrorOptions): {
135
+ name: Name;
136
+ context: Record<string, unknown>;
137
+ get message(): string;
138
+ get _tag(): Name;
162
139
  stack?: string;
163
140
  cause?: unknown;
164
141
  };
165
- code: Code;
142
+ name: Name;
166
143
  is(error: unknown): error is BaseError;
167
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
168
- #code: Code;
169
- #context: Record<string, unknown>;
170
- get name(): Code;
171
- get code(): Code;
172
- get _tag(): Code;
173
- get context(): Record<string, unknown>;
174
- message: string;
144
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
145
+ ifTypeDiffers?: boolean;
146
+ }): (error: unknown) => {
147
+ name: Name;
148
+ context: Record<string, unknown>;
149
+ get message(): string;
150
+ get _tag(): Name;
175
151
  stack?: string;
176
152
  cause?: unknown;
177
153
  };
178
- extend<Code extends string>(code: Code): /*elided*/ any;
154
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
179
155
  isError(error: unknown): error is Error;
180
156
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
181
157
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -186,59 +162,51 @@ declare const UnimplementedError_base: {
186
162
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
187
163
  stackTraceLimit: number;
188
164
  };
189
- export declare class UnimplementedError extends UnimplementedError_base {
165
+ export declare class InternalError extends InternalError_base {
190
166
  }
191
- declare const ApiError_base: {
192
- new (message: string, options?: import("./base").BaseErrorOptions): {
193
- #code: "API_ERROR";
194
- #context: Record<string, unknown>;
195
- get name(): "API_ERROR";
196
- get code(): "API_ERROR";
197
- get _tag(): "API_ERROR";
198
- get context(): Record<string, unknown>;
199
- message: string;
167
+ declare const TimeoutError_base: {
168
+ new (options?: import("./base").BaseErrorOptions): {
169
+ name: "TimeoutError";
170
+ context: Record<string, unknown>;
171
+ get message(): string;
172
+ get _tag(): "TimeoutError";
200
173
  stack?: string;
201
174
  cause?: unknown;
202
175
  };
203
- code: "API_ERROR";
176
+ name: "TimeoutError";
204
177
  is(error: unknown): error is BaseError;
205
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
206
- #code: "API_ERROR";
207
- #context: Record<string, unknown>;
208
- get name(): "API_ERROR";
209
- get code(): "API_ERROR";
210
- get _tag(): "API_ERROR";
211
- get context(): Record<string, unknown>;
212
- message: string;
178
+ wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
179
+ ifTypeDiffers?: boolean;
180
+ }) | undefined): (error: unknown) => {
181
+ name: "TimeoutError";
182
+ context: Record<string, unknown>;
183
+ get message(): string;
184
+ get _tag(): "TimeoutError";
213
185
  stack?: string;
214
186
  cause?: unknown;
215
187
  };
216
- extend<Code extends string>(code: Code): {
217
- new (message: string, options?: import("./base").BaseErrorOptions): {
218
- #code: Code;
219
- #context: Record<string, unknown>;
220
- get name(): Code;
221
- get code(): Code;
222
- get _tag(): Code;
223
- get context(): Record<string, unknown>;
224
- message: string;
188
+ extend<Name extends string = string>(name: Name, message?: string): {
189
+ new (options?: import("./base").BaseErrorOptions): {
190
+ name: Name;
191
+ context: Record<string, unknown>;
192
+ get message(): string;
193
+ get _tag(): Name;
225
194
  stack?: string;
226
195
  cause?: unknown;
227
196
  };
228
- code: Code;
197
+ name: Name;
229
198
  is(error: unknown): error is BaseError;
230
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
231
- #code: Code;
232
- #context: Record<string, unknown>;
233
- get name(): Code;
234
- get code(): Code;
235
- get _tag(): Code;
236
- get context(): Record<string, unknown>;
237
- message: string;
199
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
200
+ ifTypeDiffers?: boolean;
201
+ }): (error: unknown) => {
202
+ name: Name;
203
+ context: Record<string, unknown>;
204
+ get message(): string;
205
+ get _tag(): Name;
238
206
  stack?: string;
239
207
  cause?: unknown;
240
208
  };
241
- extend<Code extends string>(code: Code): /*elided*/ any;
209
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
242
210
  isError(error: unknown): error is Error;
243
211
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
244
212
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -249,59 +217,51 @@ declare const ApiError_base: {
249
217
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
250
218
  stackTraceLimit: number;
251
219
  };
252
- export declare class ApiError extends ApiError_base {
220
+ export declare class TimeoutError extends TimeoutError_base {
253
221
  }
254
- declare const SystemError_base: {
255
- new (message: string, options?: import("./base").BaseErrorOptions): {
256
- #code: "SYSTEM_ERROR";
257
- #context: Record<string, unknown>;
258
- get name(): "SYSTEM_ERROR";
259
- get code(): "SYSTEM_ERROR";
260
- get _tag(): "SYSTEM_ERROR";
261
- get context(): Record<string, unknown>;
262
- message: string;
222
+ declare const AbortedError_base: {
223
+ new (options?: import("./base").BaseErrorOptions): {
224
+ name: "AbortedError";
225
+ context: Record<string, unknown>;
226
+ get message(): string;
227
+ get _tag(): "AbortedError";
263
228
  stack?: string;
264
229
  cause?: unknown;
265
230
  };
266
- code: "SYSTEM_ERROR";
231
+ name: "AbortedError";
267
232
  is(error: unknown): error is BaseError;
268
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
269
- #code: "SYSTEM_ERROR";
270
- #context: Record<string, unknown>;
271
- get name(): "SYSTEM_ERROR";
272
- get code(): "SYSTEM_ERROR";
273
- get _tag(): "SYSTEM_ERROR";
274
- get context(): Record<string, unknown>;
275
- message: string;
233
+ wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
234
+ ifTypeDiffers?: boolean;
235
+ }) | undefined): (error: unknown) => {
236
+ name: "AbortedError";
237
+ context: Record<string, unknown>;
238
+ get message(): string;
239
+ get _tag(): "AbortedError";
276
240
  stack?: string;
277
241
  cause?: unknown;
278
242
  };
279
- extend<Code extends string>(code: Code): {
280
- new (message: string, options?: import("./base").BaseErrorOptions): {
281
- #code: Code;
282
- #context: Record<string, unknown>;
283
- get name(): Code;
284
- get code(): Code;
285
- get _tag(): Code;
286
- get context(): Record<string, unknown>;
287
- message: string;
243
+ extend<Name extends string = string>(name: Name, message?: string): {
244
+ new (options?: import("./base").BaseErrorOptions): {
245
+ name: Name;
246
+ context: Record<string, unknown>;
247
+ get message(): string;
248
+ get _tag(): Name;
288
249
  stack?: string;
289
250
  cause?: unknown;
290
251
  };
291
- code: Code;
252
+ name: Name;
292
253
  is(error: unknown): error is BaseError;
293
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
294
- #code: Code;
295
- #context: Record<string, unknown>;
296
- get name(): Code;
297
- get code(): Code;
298
- get _tag(): Code;
299
- get context(): Record<string, unknown>;
300
- message: string;
254
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
255
+ ifTypeDiffers?: boolean;
256
+ }): (error: unknown) => {
257
+ name: Name;
258
+ context: Record<string, unknown>;
259
+ get message(): string;
260
+ get _tag(): Name;
301
261
  stack?: string;
302
262
  cause?: unknown;
303
263
  };
304
- extend<Code extends string>(code: Code): /*elided*/ any;
264
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
305
265
  isError(error: unknown): error is Error;
306
266
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
307
267
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -312,59 +272,51 @@ declare const SystemError_base: {
312
272
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
313
273
  stackTraceLimit: number;
314
274
  };
315
- export declare class SystemError extends SystemError_base {
275
+ export declare class AbortedError extends AbortedError_base {
316
276
  }
317
- declare const InternalError_base: {
318
- new (message: string, options?: import("./base").BaseErrorOptions): {
319
- #code: "INTERNAL_ERROR";
320
- #context: Record<string, unknown>;
321
- get name(): "INTERNAL_ERROR";
322
- get code(): "INTERNAL_ERROR";
323
- get _tag(): "INTERNAL_ERROR";
324
- get context(): Record<string, unknown>;
325
- message: string;
277
+ declare const NotImplementedError_base: {
278
+ new (options?: import("./base").BaseErrorOptions): {
279
+ name: "NotImplementedError";
280
+ context: Record<string, unknown>;
281
+ get message(): string;
282
+ get _tag(): "NotImplementedError";
326
283
  stack?: string;
327
284
  cause?: unknown;
328
285
  };
329
- code: "INTERNAL_ERROR";
286
+ name: "NotImplementedError";
330
287
  is(error: unknown): error is BaseError;
331
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
332
- #code: "INTERNAL_ERROR";
333
- #context: Record<string, unknown>;
334
- get name(): "INTERNAL_ERROR";
335
- get code(): "INTERNAL_ERROR";
336
- get _tag(): "INTERNAL_ERROR";
337
- get context(): Record<string, unknown>;
338
- message: string;
288
+ wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
289
+ ifTypeDiffers?: boolean;
290
+ }) | undefined): (error: unknown) => {
291
+ name: "NotImplementedError";
292
+ context: Record<string, unknown>;
293
+ get message(): string;
294
+ get _tag(): "NotImplementedError";
339
295
  stack?: string;
340
296
  cause?: unknown;
341
297
  };
342
- extend<Code extends string>(code: Code): {
343
- new (message: string, options?: import("./base").BaseErrorOptions): {
344
- #code: Code;
345
- #context: Record<string, unknown>;
346
- get name(): Code;
347
- get code(): Code;
348
- get _tag(): Code;
349
- get context(): Record<string, unknown>;
350
- message: string;
298
+ extend<Name extends string = string>(name: Name, message?: string): {
299
+ new (options?: import("./base").BaseErrorOptions): {
300
+ name: Name;
301
+ context: Record<string, unknown>;
302
+ get message(): string;
303
+ get _tag(): Name;
351
304
  stack?: string;
352
305
  cause?: unknown;
353
306
  };
354
- code: Code;
307
+ name: Name;
355
308
  is(error: unknown): error is BaseError;
356
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
357
- #code: Code;
358
- #context: Record<string, unknown>;
359
- get name(): Code;
360
- get code(): Code;
361
- get _tag(): Code;
362
- get context(): Record<string, unknown>;
363
- message: string;
309
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
310
+ ifTypeDiffers?: boolean;
311
+ }): (error: unknown) => {
312
+ name: Name;
313
+ context: Record<string, unknown>;
314
+ get message(): string;
315
+ get _tag(): Name;
364
316
  stack?: string;
365
317
  cause?: unknown;
366
318
  };
367
- extend<Code extends string>(code: Code): /*elided*/ any;
319
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
368
320
  isError(error: unknown): error is Error;
369
321
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
370
322
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -375,7 +327,62 @@ declare const InternalError_base: {
375
327
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
376
328
  stackTraceLimit: number;
377
329
  };
378
- export declare class InternalError extends InternalError_base {
330
+ export declare class NotImplementedError extends NotImplementedError_base {
331
+ }
332
+ declare const RuntimeServiceError_base: {
333
+ new (options?: import("./base").BaseErrorOptions): {
334
+ name: "RuntimeServiceError";
335
+ context: Record<string, unknown>;
336
+ get message(): string;
337
+ get _tag(): "RuntimeServiceError";
338
+ stack?: string;
339
+ cause?: unknown;
340
+ };
341
+ name: "RuntimeServiceError";
342
+ is(error: unknown): error is BaseError;
343
+ wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
344
+ ifTypeDiffers?: boolean;
345
+ }) | undefined): (error: unknown) => {
346
+ name: "RuntimeServiceError";
347
+ context: Record<string, unknown>;
348
+ get message(): string;
349
+ get _tag(): "RuntimeServiceError";
350
+ stack?: string;
351
+ cause?: unknown;
352
+ };
353
+ extend<Name extends string = string>(name: Name, message?: string): {
354
+ new (options?: import("./base").BaseErrorOptions): {
355
+ name: Name;
356
+ context: Record<string, unknown>;
357
+ get message(): string;
358
+ get _tag(): Name;
359
+ stack?: string;
360
+ cause?: unknown;
361
+ };
362
+ name: Name;
363
+ is(error: unknown): error is BaseError;
364
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
365
+ ifTypeDiffers?: boolean;
366
+ }): (error: unknown) => {
367
+ name: Name;
368
+ context: Record<string, unknown>;
369
+ get message(): string;
370
+ get _tag(): Name;
371
+ stack?: string;
372
+ cause?: unknown;
373
+ };
374
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
375
+ isError(error: unknown): error is Error;
376
+ captureStackTrace(targetObject: object, constructorOpt?: Function): void;
377
+ prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
378
+ stackTraceLimit: number;
379
+ };
380
+ isError(error: unknown): error is Error;
381
+ captureStackTrace(targetObject: object, constructorOpt?: Function): void;
382
+ prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
383
+ stackTraceLimit: number;
384
+ };
385
+ export declare class RuntimeServiceError extends RuntimeServiceError_base {
379
386
  }
380
387
  export {};
381
388
  //# sourceMappingURL=errors.d.ts.map
package/dist/types/src/errors.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;;;;wFAa6a,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;;;AAX9d,qBAAa,YAAa,SAAQ,iBAA2B;CAAG;;;;;;;;;;;;;;;wFAWgZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;;;AAT9d,qBAAa,YAAa,SAAQ,iBAA2B;CAAG;;;;;;;;;;;;;;;wFASgZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;;;AAP9d,qBAAa,kBAAmB,SAAQ,uBAAiC;CAAG;;;;;;;;;;;;;;;wFAOoY,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;;;AAL9d,qBAAa,QAAS,SAAQ,aAA6B;CAAG;;;;;;;;;;;;;;;wFAKkZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;;;AAH9d,qBAAa,WAAY,SAAQ,gBAAgC;CAAG;;;;;;;;;;;;;;;wFAG4Y,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;;;AAD9d,qBAAa,aAAc,SAAQ,kBAAkC;CAAG"}
1
+ {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAe2S,CAAC;;;;;;;;;;;;;;;;;;;;AAb/U,qBAAa,QAAS,SAAQ,aAAyC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAaoQ,CAAC;;;;;;;;;;;;;;;;;;;;AAX/U,qBAAa,WAAY,SAAQ,gBAA+C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAW2P,CAAC;;;;;;;;;;;;;;;;;;;;AAT/U,qBAAa,aAAc,SAAQ,kBAAmD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBASqP,CAAC;;;;;;;;;;;;;;;;;;;;AAP/U,qBAAa,YAAa,SAAQ,iBAA2C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAO8P,CAAC;;;;;;;;;;;;;;;;;;;;AAL/U,qBAAa,YAAa,SAAQ,iBAA2C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAK8P,CAAC;;;;;;;;;;;;;;;;;;;;AAH/U,qBAAa,mBAAoB,SAAQ,wBAA0D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAGwO,CAAC;;;;;;;;;;;;;;;;;;;;AAD/U,qBAAa,mBAAoB,SAAQ,wBAAgE;CAAG"}