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

@marcoappio/marco-config 2.0.187 → 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 (87) hide show

package/dist/sdk/endpoints/private/sync/pull/draft.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { draft } from '../../../../../clients/draft';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../../sdk/validation/errors';
+import { errors } from '../../../../../sdk/validation/errors';
 export const syncPullDraft = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
@@ -10,8 +10,8 @@ export const syncPullDraft = createEndpoint({
     method: 'POST',
     path: draft.pullURL,
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authenticationFailedErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authFailedErrorSchema,
         v.object({
             data: v.object({
                 cookie: v.number(),

package/dist/sdk/endpoints/private/sync/pull/index.d.ts CHANGED Viewed

@@ -3,10 +3,19 @@ export declare const pull: {
         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<{
@@ -56,10 +65,19 @@ export declare const pull: {
         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<{
@@ -85,10 +103,19 @@ export declare const pull: {
         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<{
@@ -127,10 +154,19 @@ export declare const pull: {
             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<{
@@ -190,10 +226,19 @@ export declare const pull: {
         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<{

package/dist/sdk/endpoints/private/sync/pull/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/pull/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4C,CAAA"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/pull/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4C,CAAA"}

package/dist/sdk/endpoints/private/sync/pull/thread.d.ts CHANGED Viewed

@@ -7,10 +7,19 @@ export declare const syncPullThread: import("../../../../..").EndpointConfig<"/v
         readonly version: v.NumberSchema<undefined>;
     }, 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<"AUTHENTICATION_FAILED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{

package/dist/sdk/endpoints/private/sync/pull/thread.d.ts.map CHANGED Viewed

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

package/dist/sdk/endpoints/private/sync/pull/thread.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { thread } from '../../../../../clients/thread';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../../sdk/validation/errors';
+import { errors } from '../../../../../sdk/validation/errors';
 export const syncPullThread = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
@@ -14,8 +14,8 @@ export const syncPullThread = createEndpoint({
     method: 'POST',
     path: thread.pullURL,
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authenticationFailedErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authFailedErrorSchema,
         v.object({
             data: v.object({
                 cookie: v.object({

package/dist/sdk/endpoints/private/sync/pull/user.d.ts CHANGED Viewed

@@ -3,10 +3,19 @@ export declare const syncPullUser: import("../../../../..").EndpointConfig<"/v1/
     readonly clientGroupID: v.StringSchema<undefined>;
     readonly cookie: v.NullableSchema<v.NumberSchema<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<"AUTHENTICATION_FAILED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{

package/dist/sdk/endpoints/private/sync/pull/user.d.ts.map CHANGED Viewed

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

package/dist/sdk/endpoints/private/sync/pull/user.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { user } from '../../../../../clients/user';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../../sdk/validation/errors';
+import { errors } from '../../../../../sdk/validation/errors';
 export const syncPullUser = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
@@ -10,8 +10,8 @@ export const syncPullUser = createEndpoint({
     method: 'POST',
     path: user.pullURL,
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authenticationFailedErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authFailedErrorSchema,
         v.object({
             data: v.object({
                 cookie: v.number(),

package/dist/sdk/endpoints/private/sync/push/account.d.ts CHANGED Viewed

@@ -80,10 +80,19 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
         readonly name: v.LiteralSchema<"setSettings", undefined>;
     }, undefined>], 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<"AUTHENTICATION_FAILED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;

package/dist/sdk/endpoints/private/sync/push/account.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,eAAe~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAqC1B~~,CAAA"}
1	+ {"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAuC1B,CAAA"}

package/dist/sdk/endpoints/private/sync/push/account.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { account } from '../../../../../clients/account';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../../sdk/validation/errors';
+import { errors } from '../../../../../sdk/validation/errors';
 export const syncPushAccount = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
@@ -35,8 +35,8 @@ export const syncPushAccount = createEndpoint({
     method: 'POST',
     path: account.pushURL,
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authenticationFailedErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authFailedErrorSchema,
         v.object({ status: v.literal(200) }),
     ]),
 });

package/dist/sdk/endpoints/private/sync/push/draft.d.ts CHANGED Viewed

@@ -109,10 +109,19 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
         readonly name: v.LiteralSchema<"setStatus", undefined>;
     }, undefined>)[], 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<"AUTHENTICATION_FAILED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;

package/dist/sdk/endpoints/private/sync/push/draft.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/draft.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AA6C5B,eAAO,MAAM,aAAa~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~2BAcxB,CAAA"}
1	+ {"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/draft.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AA6C5B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAcxB,CAAA"}

package/dist/sdk/endpoints/private/sync/push/draft.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { draft } from '../../../../../clients/draft';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../../sdk/validation/errors';
+import { errors } from '../../../../../sdk/validation/errors';
 const mutationHandlers = {
     create: v.object({
         args: draft.mutators.create.delta,
@@ -48,8 +48,8 @@ export const syncPushDraft = createEndpoint({
     method: 'POST',
     path: draft.pushURL,
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authenticationFailedErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authFailedErrorSchema,
         v.object({ status: v.literal(200) }),
     ]),
 });

package/dist/sdk/endpoints/private/sync/push/index.d.ts CHANGED Viewed

@@ -80,10 +80,19 @@ export declare const push: {
             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>;
@@ -198,10 +207,19 @@ export declare const push: {
             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>;
@@ -219,13 +237,24 @@ export declare const push: {
             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>;
@@ -272,10 +301,19 @@ export declare const push: {
             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>;

package/dist/sdk/endpoints/private/sync/push/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmC,CAAA"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmC,CAAA"}

package/dist/sdk/endpoints/private/sync/push/thread.d.ts CHANGED Viewed

@@ -12,13 +12,24 @@ export declare const syncPushThread: import("../../../../..").EndpointConfig<"/v
         readonly name: v.LiteralSchema<"setMessageSeen", undefined>;
     }, undefined>], 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<"AUTHENTICATION_FAILED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, 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>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;

package/dist/sdk/endpoints/private/sync/push/thread.d.ts.map CHANGED Viewed

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

package/dist/sdk/endpoints/private/sync/push/thread.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { thread } from '../../../../../clients/thread';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../../sdk/validation/errors';
+import { errors } from '../../../../../sdk/validation/errors';
 export const syncPushThread = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
@@ -17,9 +17,9 @@ export const syncPushThread = createEndpoint({
     method: 'POST',
     path: thread.pushURL,
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authenticationFailedErrorSchema,
-        errorManifest.messageNotFoundErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authFailedErrorSchema,
+        errors.messageNotFoundErrorSchema,
         v.object({ status: v.literal(200) }),
     ]),
 });

package/dist/sdk/endpoints/private/sync/push/user.d.ts CHANGED Viewed

@@ -41,10 +41,19 @@ export declare const syncPushUser: import("../../../../..").EndpointConfig<"/v1/
         readonly name: v.LiteralSchema<"setSettings", undefined>;
     }, undefined>], 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<"AUTHENTICATION_FAILED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;

package/dist/sdk/endpoints/private/sync/push/user.d.ts.map CHANGED Viewed

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

package/dist/sdk/endpoints/private/sync/push/user.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { user } from '../../../../../clients/user';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../../sdk/validation/errors';
+import { errors } from '../../../../../sdk/validation/errors';
 export const syncPushUser = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
@@ -17,8 +17,8 @@ export const syncPushUser = createEndpoint({
     method: 'POST',
     path: user.pushURL,
     response: v.union([
-        errorManifest.validationFailedErrorSchema,
-        errorManifest.authenticationFailedErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.authFailedErrorSchema,
         v.object({ status: v.literal(200) }),
     ]),
 });

package/dist/sdk/endpoints/private/user/deleteUser.d.ts CHANGED Viewed

@@ -1,6 +1,8 @@
 import * as v from 'valibot';
 export declare const deleteUser: import("../../../..").EndpointConfig<"/v1/pv/user", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<204, undefined>;

package/dist/sdk/endpoints/private/user/deleteUser.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"deleteUser.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/user/deleteUser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,UAAU~~;;;;;~~2BASrB,CAAA"}
1	+ {"version":3,"file":"deleteUser.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/user/deleteUser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,UAAU;;;;;;;2BASrB,CAAA"}

package/dist/sdk/endpoints/private/user/deleteUser.js CHANGED Viewed

@@ -1,11 +1,11 @@
 import * as v from 'valibot';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { authenticationFailedErrorSchema } from '../../../../sdk/validation/errors';
+import { authFailedErrorSchema } from '../../../../sdk/validation/errors';
 export const deleteUser = createEndpoint({
     method: 'DELETE',
     path: '/v1/pv/user',
     response: v.union([
-        authenticationFailedErrorSchema,
+        authFailedErrorSchema,
         v.object({
             status: v.literal(204),
         }),

package/dist/sdk/endpoints/private/user/index.d.ts CHANGED Viewed

@@ -1,6 +1,8 @@
 export declare const 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>;

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

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