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

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 (12) hide show
  1. package/dist/lib/browser/index.mjs +1 -3
  2. package/dist/lib/browser/index.mjs.map +1 -1
  3. package/dist/lib/browser/meta.json +1 -1
  4. package/dist/lib/node-esm/index.mjs +1 -3
  5. package/dist/lib/node-esm/index.mjs.map +1 -1
  6. package/dist/lib/node-esm/meta.json +1 -1
  7. package/dist/types/src/base.d.ts +13 -12
  8. package/dist/types/src/base.d.ts.map +1 -1
  9. package/dist/types/src/errors.d.ts +156 -144
  10. package/dist/types/src/errors.d.ts.map +1 -1
  11. package/dist/types/tsconfig.tsbuildinfo +1 -1
  12. package/package.json +2 -1
package/dist/types/src/errors.d.ts CHANGED
@@ -1,12 +1,12 @@
1
1
  import { BaseError } from './base';
2
2
  declare const TimeoutError_base: {
3
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>;
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
10
  message: string;
11
11
  stack?: string;
12
12
  cause?: unknown;
@@ -14,24 +14,24 @@ declare const TimeoutError_base: {
14
14
  code: "TIMEOUT";
15
15
  is(error: unknown): error is BaseError;
16
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>;
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
23
  message: string;
24
24
  stack?: string;
25
25
  cause?: unknown;
26
26
  };
27
27
  extend<Code extends string>(code: Code): {
28
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>;
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
35
  message: string;
36
36
  stack?: string;
37
37
  cause?: unknown;
@@ -39,21 +39,23 @@ declare const TimeoutError_base: {
39
39
  code: Code;
40
40
  is(error: unknown): error is BaseError;
41
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>;
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
48
  message: string;
49
49
  stack?: string;
50
50
  cause?: unknown;
51
51
  };
52
52
  extend<Code extends string>(code: Code): /*elided*/ any;
53
+ isError(error: unknown): error is Error;
53
54
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
54
55
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
55
56
  stackTraceLimit: number;
56
57
  };
58
+ isError(error: unknown): error is Error;
57
59
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
58
60
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
59
61
  stackTraceLimit: number;
@@ -62,12 +64,12 @@ export declare class TimeoutError extends TimeoutError_base {
62
64
  }
63
65
  declare const AbortedError_base: {
64
66
  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>;
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>;
71
73
  message: string;
72
74
  stack?: string;
73
75
  cause?: unknown;
@@ -75,24 +77,24 @@ declare const AbortedError_base: {
75
77
  code: "ABORTED";
76
78
  is(error: unknown): error is BaseError;
77
79
  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>;
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>;
84
86
  message: string;
85
87
  stack?: string;
86
88
  cause?: unknown;
87
89
  };
88
90
  extend<Code extends string>(code: Code): {
89
91
  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>;
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>;
96
98
  message: string;
97
99
  stack?: string;
98
100
  cause?: unknown;
@@ -100,21 +102,23 @@ declare const AbortedError_base: {
100
102
  code: Code;
101
103
  is(error: unknown): error is BaseError;
102
104
  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>;
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>;
109
111
  message: string;
110
112
  stack?: string;
111
113
  cause?: unknown;
112
114
  };
113
115
  extend<Code extends string>(code: Code): /*elided*/ any;
116
+ isError(error: unknown): error is Error;
114
117
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
115
118
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
116
119
  stackTraceLimit: number;
117
120
  };
121
+ isError(error: unknown): error is Error;
118
122
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
119
123
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
120
124
  stackTraceLimit: number;
@@ -123,12 +127,12 @@ export declare class AbortedError extends AbortedError_base {
123
127
  }
124
128
  declare const UnimplementedError_base: {
125
129
  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>;
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>;
132
136
  message: string;
133
137
  stack?: string;
134
138
  cause?: unknown;
@@ -136,24 +140,24 @@ declare const UnimplementedError_base: {
136
140
  code: "UNIMPLEMENTED";
137
141
  is(error: unknown): error is BaseError;
138
142
  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>;
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>;
145
149
  message: string;
146
150
  stack?: string;
147
151
  cause?: unknown;
148
152
  };
149
153
  extend<Code extends string>(code: Code): {
150
154
  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>;
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>;
157
161
  message: string;
158
162
  stack?: string;
159
163
  cause?: unknown;
@@ -161,21 +165,23 @@ declare const UnimplementedError_base: {
161
165
  code: Code;
162
166
  is(error: unknown): error is BaseError;
163
167
  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>;
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>;
170
174
  message: string;
171
175
  stack?: string;
172
176
  cause?: unknown;
173
177
  };
174
178
  extend<Code extends string>(code: Code): /*elided*/ any;
179
+ isError(error: unknown): error is Error;
175
180
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
176
181
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
177
182
  stackTraceLimit: number;
178
183
  };
184
+ isError(error: unknown): error is Error;
179
185
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
180
186
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
181
187
  stackTraceLimit: number;
@@ -184,12 +190,12 @@ export declare class UnimplementedError extends UnimplementedError_base {
184
190
  }
185
191
  declare const ApiError_base: {
186
192
  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
+ #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>;
193
199
  message: string;
194
200
  stack?: string;
195
201
  cause?: unknown;
@@ -197,24 +203,24 @@ declare const ApiError_base: {
197
203
  code: "API_ERROR";
198
204
  is(error: unknown): error is BaseError;
199
205
  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
+ #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>;
206
212
  message: string;
207
213
  stack?: string;
208
214
  cause?: unknown;
209
215
  };
210
216
  extend<Code extends string>(code: Code): {
211
217
  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
+ #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>;
218
224
  message: string;
219
225
  stack?: string;
220
226
  cause?: unknown;
@@ -222,21 +228,23 @@ declare const ApiError_base: {
222
228
  code: Code;
223
229
  is(error: unknown): error is BaseError;
224
230
  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
+ #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>;
231
237
  message: string;
232
238
  stack?: string;
233
239
  cause?: unknown;
234
240
  };
235
241
  extend<Code extends string>(code: Code): /*elided*/ any;
242
+ isError(error: unknown): error is Error;
236
243
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
237
244
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
238
245
  stackTraceLimit: number;
239
246
  };
247
+ isError(error: unknown): error is Error;
240
248
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
241
249
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
242
250
  stackTraceLimit: number;
@@ -245,12 +253,12 @@ export declare class ApiError extends ApiError_base {
245
253
  }
246
254
  declare const SystemError_base: {
247
255
  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>;
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>;
254
262
  message: string;
255
263
  stack?: string;
256
264
  cause?: unknown;
@@ -258,24 +266,24 @@ declare const SystemError_base: {
258
266
  code: "SYSTEM_ERROR";
259
267
  is(error: unknown): error is BaseError;
260
268
  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>;
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>;
267
275
  message: string;
268
276
  stack?: string;
269
277
  cause?: unknown;
270
278
  };
271
279
  extend<Code extends string>(code: Code): {
272
280
  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>;
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>;
279
287
  message: string;
280
288
  stack?: string;
281
289
  cause?: unknown;
@@ -283,21 +291,23 @@ declare const SystemError_base: {
283
291
  code: Code;
284
292
  is(error: unknown): error is BaseError;
285
293
  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>;
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>;
292
300
  message: string;
293
301
  stack?: string;
294
302
  cause?: unknown;
295
303
  };
296
304
  extend<Code extends string>(code: Code): /*elided*/ any;
305
+ isError(error: unknown): error is Error;
297
306
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
298
307
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
299
308
  stackTraceLimit: number;
300
309
  };
310
+ isError(error: unknown): error is Error;
301
311
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
302
312
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
303
313
  stackTraceLimit: number;
@@ -306,12 +316,12 @@ export declare class SystemError extends SystemError_base {
306
316
  }
307
317
  declare const InternalError_base: {
308
318
  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>;
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>;
315
325
  message: string;
316
326
  stack?: string;
317
327
  cause?: unknown;
@@ -319,24 +329,24 @@ declare const InternalError_base: {
319
329
  code: "INTERNAL_ERROR";
320
330
  is(error: unknown): error is BaseError;
321
331
  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>;
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>;
328
338
  message: string;
329
339
  stack?: string;
330
340
  cause?: unknown;
331
341
  };
332
342
  extend<Code extends string>(code: Code): {
333
343
  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>;
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>;
340
350
  message: string;
341
351
  stack?: string;
342
352
  cause?: unknown;
@@ -344,21 +354,23 @@ declare const InternalError_base: {
344
354
  code: Code;
345
355
  is(error: unknown): error is BaseError;
346
356
  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>;
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>;
353
363
  message: string;
354
364
  stack?: string;
355
365
  cause?: unknown;
356
366
  };
357
367
  extend<Code extends string>(code: Code): /*elided*/ any;
368
+ isError(error: unknown): error is Error;
358
369
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
359
370
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
360
371
  stackTraceLimit: number;
361
372
  };
373
+ isError(error: unknown): error is Error;
362
374
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
363
375
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
364
376
  stackTraceLimit: number;
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;;;;;;;;;;;;;;;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"}