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