npm - @marcoappio/marco-config - Versions diffs - 2.0.188 → 2.0.190 - Mend

@marcoappio/marco-config 2.0.188 → 2.0.190

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 (81) hide show

package/dist/sdk/index.d.ts CHANGED Viewed

@@ -3,10 +3,14 @@ export declare const marcoSDK: {
         private: {
             emailMessage: {
                 getHTML: import("..").EndpointConfig<"/v1/pv/message/:messageId/html", import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<401, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<404, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
@@ -21,10 +25,19 @@ export declare const marcoSDK: {
                         readonly clientGroupID: import("valibot").StringSchema<undefined>;
                         readonly cookie: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly data: import("valibot").ObjectSchema<{
@@ -74,10 +87,19 @@ export declare const marcoSDK: {
                         readonly clientGroupID: import("valibot").StringSchema<undefined>;
                         readonly cookie: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly data: import("valibot").ObjectSchema<{
@@ -103,10 +125,19 @@ export declare const marcoSDK: {
                         readonly clientGroupID: import("valibot").StringSchema<undefined>;
                         readonly cookie: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly data: import("valibot").ObjectSchema<{
@@ -145,10 +176,19 @@ export declare const marcoSDK: {
                             readonly version: import("valibot").NumberSchema<undefined>;
                         }, undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly data: import("valibot").ObjectSchema<{
@@ -208,10 +248,19 @@ export declare const marcoSDK: {
                         readonly clientGroupID: import("valibot").StringSchema<undefined>;
                         readonly cookie: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly data: import("valibot").ObjectSchema<{
@@ -319,10 +368,19 @@ export declare const marcoSDK: {
                             readonly name: import("valibot").LiteralSchema<"setSettings", undefined>;
                         }, undefined>], undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly status: import("valibot").LiteralSchema<200, undefined>;
@@ -437,10 +495,19 @@ export declare const marcoSDK: {
                             readonly name: import("valibot").LiteralSchema<"setStatus", undefined>;
                         }, undefined>)[], undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly status: import("valibot").LiteralSchema<200, undefined>;
@@ -458,13 +525,24 @@ export declare const marcoSDK: {
                             readonly name: import("valibot").LiteralSchema<"setMessageSeen", undefined>;
                         }, undefined>], undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<404, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly status: import("valibot").LiteralSchema<200, undefined>;
@@ -511,10 +589,19 @@ export declare const marcoSDK: {
                             readonly name: import("valibot").LiteralSchema<"setSettings", undefined>;
                         }, undefined>], undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly status: import("valibot").LiteralSchema<200, undefined>;
@@ -523,7 +610,9 @@ export declare const marcoSDK: {
             };
             user: {
                 deleteUser: import("..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<401, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly status: import("valibot").LiteralSchema<204, undefined>;
@@ -535,13 +624,24 @@ export declare const marcoSDK: {
                 refreshAuth: import("..").EndpointConfig<"/v1/pb/auth/refresh", import("valibot").ObjectSchema<{
                     readonly refreshToken: import("valibot").StringSchema<undefined>;
                 }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly issues: import("valibot").ObjectSchema<{
+                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                            readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<400, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<401, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<502, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
@@ -563,10 +663,19 @@ export declare const marcoSDK: {
                 sendAuthCode: import("..").EndpointConfig<"/v1/pb/auth/send-code", import("valibot").ObjectSchema<{
                     readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly issues: import("valibot").ObjectSchema<{
+                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                            readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<400, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<502, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly status: import("valibot").LiteralSchema<200, undefined>;
@@ -575,22 +684,39 @@ export declare const marcoSDK: {
                     readonly code: import("valibot").StringSchema<undefined>;
                     readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly issues: import("valibot").ObjectSchema<{
+                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                            readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<400, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<401, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<401, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<401, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<502, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
+                    }, undefined>;
                     readonly status: import("valibot").LiteralSchema<404, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
@@ -619,6 +745,67 @@ export declare const marcoSDK: {
         };
     };
     validation: {
+        errors: {
+            readonly authCodeExpiredErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>;
+            readonly authCodePreviouslyUsedErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>;
+            readonly authFailedErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>;
+            readonly authRefreshTokenInvalid: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>;
+            readonly authServerResponseUnexpectedErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<502, undefined>;
+            }, undefined>;
+            readonly authTooManyAttemptsErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>;
+            readonly messageNotFoundErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<404, undefined>;
+            }, undefined>;
+            readonly userNotFoundErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<404, undefined>;
+            }, undefined>;
+            readonly validationFailedErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                    readonly issues: import("valibot").ObjectSchema<{
+                        readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                        readonly other: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                        readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<400, undefined>;
+            }, undefined>;
+        };
         utils: {
             flattenRequirements: <T extends Record<string, any>>(schema: import("valibot").ObjectSchema<T, any>) => { [K in keyof T]: {
                 maxLength?: number;

package/dist/sdk/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAA"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAA"}

package/dist/sdk/validation/errors.d.ts CHANGED Viewed

@@ -1,75 +1,121 @@
 import * as v from 'valibot';
 export declare const authCodeExpiredErrorSchema: v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>;
 export declare const authTooManyAttemptsErrorSchema: v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>;
 export declare const authCodePreviouslyUsedErrorSchema: v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>;
 export declare const authServerResponseUnexpectedErrorSchema: v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<502, undefined>;
 }, undefined>;
-export declare const authenticationFailedErrorSchema: v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+export declare const authFailedErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>;
 export declare const authRefreshTokenInvalid: v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>;
 export declare const userNotFoundErrorSchema: v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<404, undefined>;
 }, undefined>;
 export declare const messageNotFoundErrorSchema: v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<404, undefined>;
 }, undefined>;
 export declare const validationFailedErrorSchema: v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<400, undefined>;
 }, undefined>;
-export declare const errorManifest: {
-    authCodeExpiredErrorSchema: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+export declare const errors: {
+    readonly authCodeExpiredErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+        }, undefined>;
         readonly status: v.LiteralSchema<401, undefined>;
     }, undefined>;
-    authCodePreviouslyUsedErrorSchema: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+    readonly authCodePreviouslyUsedErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+        }, undefined>;
         readonly status: v.LiteralSchema<401, undefined>;
     }, undefined>;
-    authRefreshTokenInvalid: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+    readonly authFailedErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+        }, undefined>;
         readonly status: v.LiteralSchema<401, undefined>;
     }, undefined>;
-    authServerResponseUnexpectedErrorSchema: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-        readonly status: v.LiteralSchema<502, undefined>;
-    }, undefined>;
-    authTooManyAttemptsErrorSchema: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+    readonly authRefreshTokenInvalid: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+        }, undefined>;
         readonly status: v.LiteralSchema<401, undefined>;
     }, undefined>;
-    authenticationFailedErrorSchema: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    readonly authServerResponseUnexpectedErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<502, undefined>;
+    }, undefined>;
+    readonly authTooManyAttemptsErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+        }, undefined>;
         readonly status: v.LiteralSchema<401, undefined>;
     }, undefined>;
-    messageNotFoundErrorSchema: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+    readonly messageNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+        }, undefined>;
         readonly status: v.LiteralSchema<404, undefined>;
     }, undefined>;
-    userNotFoundErrorSchema: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+    readonly userNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+        }, undefined>;
         readonly status: v.LiteralSchema<404, undefined>;
     }, undefined>;
-    validationFailedErrorSchema: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+    readonly validationFailedErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+            readonly issues: v.ObjectSchema<{
+                readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>;
+                readonly other: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>;
+                readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
         readonly status: v.LiteralSchema<400, undefined>;
     }, undefined>;
 };

package/dist/sdk/validation/errors.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/errors.ts"],"names":[],"mappings":"~~AACA~~,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;~~AAQ5B~~,eAAO,MAAM,0BAA0B~~;;;~~aAGrC,CAAA;AAEF,eAAO,MAAM,8BAA8B~~;;;~~aAGzC,CAAA;AAEF,eAAO,MAAM,iCAAiC~~;;;~~aAG5C,CAAA;AAEF,eAAO,MAAM,uCAAuC~~;;;~~aAGlD,CAAA;AAEF,eAAO,MAAM~~,+BAA+B;;;aAG1C~~,CAAA;AAEF,eAAO,MAAM,uBAAuB~~;;;~~aAGlC,CAAA;AAEF,eAAO,MAAM,uBAAuB~~;;;~~aAGlC,CAAA;AAEF,eAAO,MAAM,0BAA0B~~;;;~~aAGrC,CAAA;AAEF,eAAO,MAAM,2BAA2B~~;;;aAGtC~~,CAAA;AAEF,eAAO,MAAM,~~aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUD~~,CAAA"}
1	+ {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;aAGzC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;aAGlD,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;aAGhC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;aAUtC,CAAA;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUT,CAAA"}