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

@marcoappio/marco-config 2.0.188 → 2.0.189

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/endpoints/public/auth/index.d.ts CHANGED Viewed

@@ -2,13 +2,24 @@ export declare const auth: {
     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<{
@@ -30,10 +41,19 @@ export declare const auth: {
     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>;
@@ -42,22 +62,39 @@ export declare const auth: {
         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<{

package/dist/sdk/endpoints/public/auth/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~CAIhB,CAAA"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIhB,CAAA"}

package/dist/sdk/endpoints/public/auth/refreshAuth.d.ts CHANGED Viewed

@@ -2,13 +2,24 @@ import * as v from 'valibot';
 export declare const refreshAuth: import("../../../..").EndpointConfig<"/v1/pb/auth/refresh", v.ObjectSchema<{
     readonly refreshToken: v.StringSchema<undefined>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[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>, 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>, 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>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{

package/dist/sdk/endpoints/public/auth/refreshAuth.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"refreshAuth.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/refreshAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,WAAW~~;;;;;;;;;;;;;;;;;;;;;;;;;;;~~2BA4BtB,CAAA"}
1	+ {"version":3,"file":"refreshAuth.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/refreshAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA4BtB,CAAA"}

package/dist/sdk/endpoints/public/auth/refreshAuth.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../../schemas';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../sdk/validation/errors';
+import { errors } from '../../../../sdk/validation/errors';
 export const refreshAuth = createEndpoint({
     body: v.object({
         refreshToken: v.string(),
@@ -9,9 +9,9 @@ export const refreshAuth = createEndpoint({
     method: 'POST',
     path: '/v1/pb/auth/refresh',
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authRefreshTokenInvalid,
-        errorManifest.authServerResponseUnexpectedErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authRefreshTokenInvalid,
+        errors.authServerResponseUnexpectedErrorSchema,
         v.object({
             data: v.object({
                 accessToken: v.string(),

package/dist/sdk/endpoints/public/auth/sendAuthCode.d.ts CHANGED Viewed

@@ -2,10 +2,19 @@ import * as v from 'valibot';
 export declare const sendAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/send-code", v.ObjectSchema<{
     readonly email: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[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>, 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>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;

package/dist/sdk/endpoints/public/auth/sendAuthCode.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"sendAuthCode.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/sendAuthCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,YAAY~~;;;;;;;;;;~~2BAavB,CAAA"}
1	+ {"version":3,"file":"sendAuthCode.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/sendAuthCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;2BAavB,CAAA"}

package/dist/sdk/endpoints/public/auth/sendAuthCode.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../../schemas';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../sdk/validation/errors';
+import { errors } from '../../../../sdk/validation/errors';
 export const sendAuthCode = createEndpoint({
     body: v.object({
         email: marcoSchemas.string.email(),
@@ -9,8 +9,8 @@ export const sendAuthCode = createEndpoint({
     method: 'POST',
     path: '/v1/pb/auth/send-code',
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authServerResponseUnexpectedErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authServerResponseUnexpectedErrorSchema,
         v.object({
             status: v.literal(200),
         }),

package/dist/sdk/endpoints/public/auth/verifyAuthCode.d.ts CHANGED Viewed

@@ -3,22 +3,39 @@ export declare const verifyAuthCode: import("../../../..").EndpointConfig<"/v1/p
     readonly code: v.StringSchema<undefined>;
     readonly email: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[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>, 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>, 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>, 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>, 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>, 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>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{

package/dist/sdk/endpoints/public/auth/verifyAuthCode.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"verifyAuthCode.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/verifyAuthCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,cAAc~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~2BAgCzB,CAAA"}
1	+ {"version":3,"file":"verifyAuthCode.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/verifyAuthCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAgCzB,CAAA"}

package/dist/sdk/endpoints/public/auth/verifyAuthCode.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../../schemas';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../sdk/validation/errors';
+import { errors } from '../../../../sdk/validation/errors';
 export const verifyAuthCode = createEndpoint({
     body: v.object({
         code: v.string(),
@@ -10,12 +10,12 @@ export const verifyAuthCode = createEndpoint({
     method: 'POST',
     path: '/v1/pb/auth/verify-code',
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authCodeExpiredErrorSchema,
-        errorManifest.authCodePreviouslyUsedErrorSchema,
-        errorManifest.authTooManyAttemptsErrorSchema,
-        errorManifest.authServerResponseUnexpectedErrorSchema,
-        errorManifest.userNotFoundErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authCodeExpiredErrorSchema,
+        errors.authCodePreviouslyUsedErrorSchema,
+        errors.authTooManyAttemptsErrorSchema,
+        errors.authServerResponseUnexpectedErrorSchema,
+        errors.userNotFoundErrorSchema,
         v.object({
             data: v.object({
                 accessToken: v.string(),

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

@@ -3,13 +3,24 @@ export declare const publicGroup: {
         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<{
@@ -31,10 +42,19 @@ export declare const publicGroup: {
         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>;
@@ -43,22 +63,39 @@ export declare const publicGroup: {
             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<{

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

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