@dxos/errors 0.8.4-main.dedc0f3 → 0.8.4-main.e8ec1fe

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