@dxos/errors 0.8.4-main.67995b8 → 0.8.4-main.69d29f4

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 -42
  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 -42
  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 +34 -36
  8. package/dist/types/src/base.d.ts.map +1 -1
  9. package/dist/types/src/errors.d.ts +247 -228
  10. package/dist/types/src/errors.d.ts.map +1 -1
  11. package/dist/types/tsconfig.tsbuildinfo +1 -1
  12. package/package.json +8 -4
  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,369 +1,388 @@
1
1
  import { BaseError } from './base';
2
- declare const TimeoutError_base: {
3
- new (message: string, options?: import("./base").BaseErrorOptions): {
4
- "__#1@#code": "TIMEOUT";
5
- "__#1@#context": Record<string, unknown>;
6
- readonly name: "TIMEOUT";
7
- readonly code: "TIMEOUT";
8
- readonly _tag: "TIMEOUT";
9
- readonly 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
- "__#1@#code": "TIMEOUT";
18
- "__#1@#context": Record<string, unknown>;
19
- readonly name: "TIMEOUT";
20
- readonly code: "TIMEOUT";
21
- readonly _tag: "TIMEOUT";
22
- readonly 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
- "__#1@#code": Code;
30
- "__#1@#context": Record<string, unknown>;
31
- readonly name: Code;
32
- readonly code: Code;
33
- readonly _tag: Code;
34
- readonly 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
- "__#1@#code": Code;
43
- "__#1@#context": Record<string, unknown>;
44
- readonly name: Code;
45
- readonly code: Code;
46
- readonly _tag: Code;
47
- readonly 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;
45
+ isError(error: unknown): error is Error;
53
46
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
54
47
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
55
48
  stackTraceLimit: number;
56
49
  };
50
+ isError(error: unknown): error is Error;
57
51
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
58
52
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
59
53
  stackTraceLimit: number;
60
54
  };
61
- export declare class TimeoutError extends TimeoutError_base {
55
+ export declare class ApiError extends ApiError_base {
62
56
  }
63
- declare const AbortedError_base: {
64
- new (message: string, options?: import("./base").BaseErrorOptions): {
65
- "__#1@#code": "ABORTED";
66
- "__#1@#context": Record<string, unknown>;
67
- readonly name: "ABORTED";
68
- readonly code: "ABORTED";
69
- readonly _tag: "ABORTED";
70
- readonly context: Record<string, unknown>;
71
- 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";
72
63
  stack?: string;
73
64
  cause?: unknown;
74
65
  };
75
- code: "ABORTED";
66
+ name: "SystemError";
76
67
  is(error: unknown): error is BaseError;
77
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
78
- "__#1@#code": "ABORTED";
79
- "__#1@#context": Record<string, unknown>;
80
- readonly name: "ABORTED";
81
- readonly code: "ABORTED";
82
- readonly _tag: "ABORTED";
83
- readonly context: Record<string, unknown>;
84
- 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";
85
75
  stack?: string;
86
76
  cause?: unknown;
87
77
  };
88
- extend<Code extends string>(code: Code): {
89
- new (message: string, options?: import("./base").BaseErrorOptions): {
90
- "__#1@#code": Code;
91
- "__#1@#context": Record<string, unknown>;
92
- readonly name: Code;
93
- readonly code: Code;
94
- readonly _tag: Code;
95
- readonly context: Record<string, unknown>;
96
- 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;
97
84
  stack?: string;
98
85
  cause?: unknown;
99
86
  };
100
- code: Code;
87
+ name: Name;
101
88
  is(error: unknown): error is BaseError;
102
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
103
- "__#1@#code": Code;
104
- "__#1@#context": Record<string, unknown>;
105
- readonly name: Code;
106
- readonly code: Code;
107
- readonly _tag: Code;
108
- readonly context: Record<string, unknown>;
109
- 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;
110
96
  stack?: string;
111
97
  cause?: unknown;
112
98
  };
113
- extend<Code extends string>(code: Code): /*elided*/ any;
99
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
100
+ isError(error: unknown): error is Error;
114
101
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
115
102
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
116
103
  stackTraceLimit: number;
117
104
  };
105
+ isError(error: unknown): error is Error;
118
106
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
119
107
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
120
108
  stackTraceLimit: number;
121
109
  };
122
- export declare class AbortedError extends AbortedError_base {
110
+ export declare class SystemError extends SystemError_base {
123
111
  }
124
- declare const UnimplementedError_base: {
125
- new (message: string, options?: import("./base").BaseErrorOptions): {
126
- "__#1@#code": "UNIMPLEMENTED";
127
- "__#1@#context": Record<string, unknown>;
128
- readonly name: "UNIMPLEMENTED";
129
- readonly code: "UNIMPLEMENTED";
130
- readonly _tag: "UNIMPLEMENTED";
131
- readonly context: Record<string, unknown>;
132
- 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";
133
118
  stack?: string;
134
119
  cause?: unknown;
135
120
  };
136
- code: "UNIMPLEMENTED";
121
+ name: "InternalError";
137
122
  is(error: unknown): error is BaseError;
138
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
139
- "__#1@#code": "UNIMPLEMENTED";
140
- "__#1@#context": Record<string, unknown>;
141
- readonly name: "UNIMPLEMENTED";
142
- readonly code: "UNIMPLEMENTED";
143
- readonly _tag: "UNIMPLEMENTED";
144
- readonly context: Record<string, unknown>;
145
- 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";
146
130
  stack?: string;
147
131
  cause?: unknown;
148
132
  };
149
- extend<Code extends string>(code: Code): {
150
- new (message: string, options?: import("./base").BaseErrorOptions): {
151
- "__#1@#code": Code;
152
- "__#1@#context": Record<string, unknown>;
153
- readonly name: Code;
154
- readonly code: Code;
155
- readonly _tag: Code;
156
- readonly context: Record<string, unknown>;
157
- 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;
158
139
  stack?: string;
159
140
  cause?: unknown;
160
141
  };
161
- code: Code;
142
+ name: Name;
162
143
  is(error: unknown): error is BaseError;
163
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
164
- "__#1@#code": Code;
165
- "__#1@#context": Record<string, unknown>;
166
- readonly name: Code;
167
- readonly code: Code;
168
- readonly _tag: Code;
169
- readonly context: Record<string, unknown>;
170
- 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;
171
151
  stack?: string;
172
152
  cause?: unknown;
173
153
  };
174
- extend<Code extends string>(code: Code): /*elided*/ any;
154
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
155
+ isError(error: unknown): error is Error;
175
156
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
176
157
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
177
158
  stackTraceLimit: number;
178
159
  };
160
+ isError(error: unknown): error is Error;
179
161
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
180
162
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
181
163
  stackTraceLimit: number;
182
164
  };
183
- export declare class UnimplementedError extends UnimplementedError_base {
165
+ export declare class InternalError extends InternalError_base {
184
166
  }
185
- declare const ApiError_base: {
186
- new (message: string, options?: import("./base").BaseErrorOptions): {
187
- "__#1@#code": "API_ERROR";
188
- "__#1@#context": Record<string, unknown>;
189
- readonly name: "API_ERROR";
190
- readonly code: "API_ERROR";
191
- readonly _tag: "API_ERROR";
192
- readonly context: Record<string, unknown>;
193
- 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";
194
173
  stack?: string;
195
174
  cause?: unknown;
196
175
  };
197
- code: "API_ERROR";
176
+ name: "TimeoutError";
198
177
  is(error: unknown): error is BaseError;
199
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
200
- "__#1@#code": "API_ERROR";
201
- "__#1@#context": Record<string, unknown>;
202
- readonly name: "API_ERROR";
203
- readonly code: "API_ERROR";
204
- readonly _tag: "API_ERROR";
205
- readonly context: Record<string, unknown>;
206
- 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";
207
185
  stack?: string;
208
186
  cause?: unknown;
209
187
  };
210
- extend<Code extends string>(code: Code): {
211
- new (message: string, options?: import("./base").BaseErrorOptions): {
212
- "__#1@#code": Code;
213
- "__#1@#context": Record<string, unknown>;
214
- readonly name: Code;
215
- readonly code: Code;
216
- readonly _tag: Code;
217
- readonly context: Record<string, unknown>;
218
- 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;
219
194
  stack?: string;
220
195
  cause?: unknown;
221
196
  };
222
- code: Code;
197
+ name: Name;
223
198
  is(error: unknown): error is BaseError;
224
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
225
- "__#1@#code": Code;
226
- "__#1@#context": Record<string, unknown>;
227
- readonly name: Code;
228
- readonly code: Code;
229
- readonly _tag: Code;
230
- readonly context: Record<string, unknown>;
231
- 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;
232
206
  stack?: string;
233
207
  cause?: unknown;
234
208
  };
235
- extend<Code extends string>(code: Code): /*elided*/ any;
209
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
210
+ isError(error: unknown): error is Error;
236
211
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
237
212
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
238
213
  stackTraceLimit: number;
239
214
  };
215
+ isError(error: unknown): error is Error;
240
216
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
241
217
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
242
218
  stackTraceLimit: number;
243
219
  };
244
- export declare class ApiError extends ApiError_base {
220
+ export declare class TimeoutError extends TimeoutError_base {
245
221
  }
246
- declare const SystemError_base: {
247
- new (message: string, options?: import("./base").BaseErrorOptions): {
248
- "__#1@#code": "SYSTEM_ERROR";
249
- "__#1@#context": Record<string, unknown>;
250
- readonly name: "SYSTEM_ERROR";
251
- readonly code: "SYSTEM_ERROR";
252
- readonly _tag: "SYSTEM_ERROR";
253
- readonly context: Record<string, unknown>;
254
- 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";
255
228
  stack?: string;
256
229
  cause?: unknown;
257
230
  };
258
- code: "SYSTEM_ERROR";
231
+ name: "AbortedError";
259
232
  is(error: unknown): error is BaseError;
260
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
261
- "__#1@#code": "SYSTEM_ERROR";
262
- "__#1@#context": Record<string, unknown>;
263
- readonly name: "SYSTEM_ERROR";
264
- readonly code: "SYSTEM_ERROR";
265
- readonly _tag: "SYSTEM_ERROR";
266
- readonly context: Record<string, unknown>;
267
- 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";
268
240
  stack?: string;
269
241
  cause?: unknown;
270
242
  };
271
- extend<Code extends string>(code: Code): {
272
- new (message: string, options?: import("./base").BaseErrorOptions): {
273
- "__#1@#code": Code;
274
- "__#1@#context": Record<string, unknown>;
275
- readonly name: Code;
276
- readonly code: Code;
277
- readonly _tag: Code;
278
- readonly context: Record<string, unknown>;
279
- 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;
280
249
  stack?: string;
281
250
  cause?: unknown;
282
251
  };
283
- code: Code;
252
+ name: Name;
284
253
  is(error: unknown): error is BaseError;
285
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
286
- "__#1@#code": Code;
287
- "__#1@#context": Record<string, unknown>;
288
- readonly name: Code;
289
- readonly code: Code;
290
- readonly _tag: Code;
291
- readonly context: Record<string, unknown>;
292
- 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;
293
261
  stack?: string;
294
262
  cause?: unknown;
295
263
  };
296
- extend<Code extends string>(code: Code): /*elided*/ any;
264
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
265
+ isError(error: unknown): error is Error;
297
266
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
298
267
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
299
268
  stackTraceLimit: number;
300
269
  };
270
+ isError(error: unknown): error is Error;
301
271
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
302
272
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
303
273
  stackTraceLimit: number;
304
274
  };
305
- export declare class SystemError extends SystemError_base {
275
+ export declare class AbortedError extends AbortedError_base {
306
276
  }
307
- declare const InternalError_base: {
308
- new (message: string, options?: import("./base").BaseErrorOptions): {
309
- "__#1@#code": "INTERNAL_ERROR";
310
- "__#1@#context": Record<string, unknown>;
311
- readonly name: "INTERNAL_ERROR";
312
- readonly code: "INTERNAL_ERROR";
313
- readonly _tag: "INTERNAL_ERROR";
314
- readonly context: Record<string, unknown>;
315
- 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";
316
283
  stack?: string;
317
284
  cause?: unknown;
318
285
  };
319
- code: "INTERNAL_ERROR";
286
+ name: "NotImplementedError";
320
287
  is(error: unknown): error is BaseError;
321
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
322
- "__#1@#code": "INTERNAL_ERROR";
323
- "__#1@#context": Record<string, unknown>;
324
- readonly name: "INTERNAL_ERROR";
325
- readonly code: "INTERNAL_ERROR";
326
- readonly _tag: "INTERNAL_ERROR";
327
- readonly context: Record<string, unknown>;
328
- 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";
329
295
  stack?: string;
330
296
  cause?: unknown;
331
297
  };
332
- extend<Code extends string>(code: Code): {
333
- new (message: string, options?: import("./base").BaseErrorOptions): {
334
- "__#1@#code": Code;
335
- "__#1@#context": Record<string, unknown>;
336
- readonly name: Code;
337
- readonly code: Code;
338
- readonly _tag: Code;
339
- readonly context: Record<string, unknown>;
340
- 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;
341
304
  stack?: string;
342
305
  cause?: unknown;
343
306
  };
344
- code: Code;
307
+ name: Name;
345
308
  is(error: unknown): error is BaseError;
346
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
347
- "__#1@#code": Code;
348
- "__#1@#context": Record<string, unknown>;
349
- readonly name: Code;
350
- readonly code: Code;
351
- readonly _tag: Code;
352
- readonly context: Record<string, unknown>;
353
- 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;
354
316
  stack?: string;
355
317
  cause?: unknown;
356
318
  };
357
- extend<Code extends string>(code: Code): /*elided*/ any;
319
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
320
+ isError(error: unknown): error is Error;
358
321
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
359
322
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
360
323
  stackTraceLimit: number;
361
324
  };
325
+ isError(error: unknown): error is Error;
362
326
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
363
327
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
364
328
  stackTraceLimit: number;
365
329
  };
366
- 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 {
367
386
  }
368
387
  export {};
369
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"}