@marcoappio/marco-config 2.0.206 → 2.0.208

package/dist/clients/index.d.ts

@@ -300,8 +300,7 @@ export declare const marcoClients: {
         model: import("valibot").ObjectSchema<{
             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly settings: import("valibot").ObjectSchema<{
-                readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             }, undefined>;
         }, undefined>;
         mutators: {
@@ -309,32 +308,25 @@ export declare const marcoClients: {
                 delta: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly settings: Omit<import("valibot").ObjectSchema<{
-                        readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                        readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                         readonly entries: {
-                            readonly firstName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                            readonly lastName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                            readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                         };
                         readonly '~standard': import("valibot").StandardSchemaProps<{
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         }, {
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         }>;
                         readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         }, import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>>;
                         readonly '~types'?: {
                             readonly input: {
-                                firstName?: string | null | undefined;
-                                lastName?: string | null | undefined;
+                                name?: string | null | undefined;
                             };
                             readonly output: {
-                                firstName?: string | null | undefined;
-                                lastName?: string | null | undefined;
+                                name?: string | null | undefined;
                             };
                             readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>;
                         } | undefined;

package/dist/clients/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clients/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clients/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMc,CAAA"}

package/dist/clients/user.d.ts

@@ -3,8 +3,7 @@ export declare const user: {
     model: v.ObjectSchema<{
         readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly settings: v.ObjectSchema<{
-            readonly firstName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly lastName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
     }, undefined>;
     mutators: {
@@ -12,32 +11,25 @@ export declare const user: {
             delta: v.ObjectSchema<{
                 readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly settings: Omit<v.ObjectSchema<{
-                    readonly firstName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                    readonly lastName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                     readonly entries: {
-                        readonly firstName: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                        readonly lastName: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                        readonly name: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                     };
                     readonly '~standard': v.StandardSchemaProps<{
-                        firstName?: string | null | undefined;
-                        lastName?: string | null | undefined;
+                        name?: string | null | undefined;
                     }, {
-                        firstName?: string | null | undefined;
-                        lastName?: string | null | undefined;
+                        name?: string | null | undefined;
                     }>;
                     readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
-                        firstName?: string | null | undefined;
-                        lastName?: string | null | undefined;
+                        name?: string | null | undefined;
                     }, v.StringIssue | v.ObjectIssue | v.MaxLengthIssue<string, number>>;
                     readonly '~types'?: {
                         readonly input: {
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         };
                         readonly output: {
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         };
                         readonly issue: v.StringIssue | v.ObjectIssue | v.MaxLengthIssue<string, number>;
                     } | undefined;

package/dist/clients/user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/clients/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBM,CAAA"}
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/clients/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAS5B,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBM,CAAA"}

package/dist/clients/user.js

@@ -1,8 +1,7 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../schemas';
 const userSettings = v.object({
-    firstName: marcoSchemas.string.nullable(),
-    lastName: marcoSchemas.string.nullable(),
+    name: marcoSchemas.string.nullable(),
 });
 export const user = {
     model: v.object({

package/dist/sdk/endpoints/index.d.ts

@@ -281,8 +281,7 @@ export declare const endpoints: {
                             readonly value: import("valibot").ObjectSchema<{
                                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly settings: import("valibot").ObjectSchema<{
-                                    readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                                    readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 }, undefined>;
                             }, undefined>;
                         }, undefined>], undefined>, undefined>;
@@ -379,6 +378,11 @@ export declare const endpoints: {
                         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<{
+                        readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<409, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly status: import("valibot").LiteralSchema<200, undefined>;
                 }, undefined>], undefined>>;
@@ -506,6 +510,11 @@ export declare const endpoints: {
                         }, undefined>;
                     }, undefined>;
                     readonly status: import("valibot").LiteralSchema<400, undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<409, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
                         readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
@@ -565,9 +574,9 @@ export declare const endpoints: {
                     readonly status: import("valibot").LiteralSchema<401, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                        readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
                     }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<404, undefined>;
+                    readonly status: import("valibot").LiteralSchema<409, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly status: import("valibot").LiteralSchema<200, undefined>;
                 }, undefined>], undefined>>;
@@ -577,32 +586,25 @@ export declare const endpoints: {
                         readonly args: import("valibot").ObjectSchema<{
                             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly settings: Omit<import("valibot").ObjectSchema<{
-                                readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                                readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                                 readonly entries: {
-                                    readonly firstName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                                    readonly lastName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                                    readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                                 };
                                 readonly '~standard': import("valibot").StandardSchemaProps<{
-                                    firstName?: string | null | undefined;
-                                    lastName?: string | null | undefined;
+                                    name?: string | null | undefined;
                                 }, {
-                                    firstName?: string | null | undefined;
-                                    lastName?: string | null | undefined;
+                                    name?: string | null | undefined;
                                 }>;
                                 readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                                    firstName?: string | null | undefined;
-                                    lastName?: string | null | undefined;
+                                    name?: string | null | undefined;
                                 }, import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>>;
                                 readonly '~types'?: {
                                     readonly input: {
-                                        firstName?: string | null | undefined;
-                                        lastName?: string | null | undefined;
+                                        name?: string | null | undefined;
                                     };
                                     readonly output: {
-                                        firstName?: string | null | undefined;
-                                        lastName?: string | null | undefined;
+                                        name?: string | null | undefined;
                                     };
                                     readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>;
                                 } | undefined;
@@ -627,6 +629,11 @@ export declare const endpoints: {
                         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<{
+                        readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<409, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly status: import("valibot").LiteralSchema<200, undefined>;
                 }, undefined>], undefined>>;

package/dist/sdk/endpoints/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC,OAAO,EAAE,cAAc,EAAe,MAAM,qBAAqB,CAAA;AAcjE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC,OAAO,EAAE,cAAc,EAAe,MAAM,qBAAqB,CAAA;AAcjE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}

package/dist/sdk/endpoints/private/index.d.ts

@@ -278,8 +278,7 @@ export declare const privateGroup: {
                         readonly value: import("valibot").ObjectSchema<{
                             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly settings: import("valibot").ObjectSchema<{
-                                readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                                readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             }, undefined>;
                         }, undefined>;
                     }, undefined>], undefined>, undefined>;
@@ -376,6 +375,11 @@ export declare const privateGroup: {
                     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<{
+                    readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<409, undefined>;
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
             }, undefined>], undefined>>;
@@ -503,6 +507,11 @@ export declare const privateGroup: {
                     }, undefined>;
                 }, undefined>;
                 readonly status: import("valibot").LiteralSchema<400, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<409, undefined>;
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
@@ -562,9 +571,9 @@ export declare const privateGroup: {
                 readonly status: import("valibot").LiteralSchema<401, undefined>;
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                    readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
                 }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
+                readonly status: import("valibot").LiteralSchema<409, undefined>;
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
             }, undefined>], undefined>>;
@@ -574,32 +583,25 @@ export declare const privateGroup: {
                     readonly args: import("valibot").ObjectSchema<{
                         readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly settings: Omit<import("valibot").ObjectSchema<{
-                            readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                            readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                             readonly entries: {
-                                readonly firstName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                                readonly lastName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                                readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                             };
                             readonly '~standard': import("valibot").StandardSchemaProps<{
-                                firstName?: string | null | undefined;
-                                lastName?: string | null | undefined;
+                                name?: string | null | undefined;
                             }, {
-                                firstName?: string | null | undefined;
-                                lastName?: string | null | undefined;
+                                name?: string | null | undefined;
                             }>;
                             readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                                firstName?: string | null | undefined;
-                                lastName?: string | null | undefined;
+                                name?: string | null | undefined;
                             }, import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>>;
                             readonly '~types'?: {
                                 readonly input: {
-                                    firstName?: string | null | undefined;
-                                    lastName?: string | null | undefined;
+                                    name?: string | null | undefined;
                                 };
                                 readonly output: {
-                                    firstName?: string | null | undefined;
-                                    lastName?: string | null | undefined;
+                                    name?: string | null | undefined;
                                 };
                                 readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>;
                             } | undefined;
@@ -624,6 +626,11 @@ export declare const privateGroup: {
                     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<{
+                    readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<409, undefined>;
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
             }, undefined>], undefined>>;

package/dist/sdk/endpoints/private/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sdk/endpoints/private/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIxB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sdk/endpoints/private/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIxB,CAAA"}

package/dist/sdk/endpoints/private/sync/index.d.ts

@@ -259,8 +259,7 @@ export declare const sync: {
                     readonly value: import("valibot").ObjectSchema<{
                         readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly settings: import("valibot").ObjectSchema<{
-                            readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                            readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         }, undefined>;
                     }, undefined>;
                 }, undefined>], undefined>, undefined>;
@@ -357,6 +356,11 @@ export declare const sync: {
                 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<{
+                readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<409, undefined>;
         }, undefined>, import("valibot").ObjectSchema<{
             readonly status: import("valibot").LiteralSchema<200, undefined>;
         }, undefined>], undefined>>;
@@ -484,6 +488,11 @@ export declare const sync: {
                 }, undefined>;
             }, undefined>;
             readonly status: import("valibot").LiteralSchema<400, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<409, undefined>;
         }, undefined>, import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
@@ -543,9 +552,9 @@ export declare const sync: {
             readonly status: import("valibot").LiteralSchema<401, undefined>;
         }, undefined>, import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
             }, undefined>;
-            readonly status: import("valibot").LiteralSchema<404, undefined>;
+            readonly status: import("valibot").LiteralSchema<409, undefined>;
         }, undefined>, import("valibot").ObjectSchema<{
             readonly status: import("valibot").LiteralSchema<200, undefined>;
         }, undefined>], undefined>>;
@@ -555,32 +564,25 @@ export declare const sync: {
                 readonly args: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly settings: Omit<import("valibot").ObjectSchema<{
-                        readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                        readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                         readonly entries: {
-                            readonly firstName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                            readonly lastName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                            readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                         };
                         readonly '~standard': import("valibot").StandardSchemaProps<{
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         }, {
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         }>;
                         readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         }, import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>>;
                         readonly '~types'?: {
                             readonly input: {
-                                firstName?: string | null | undefined;
-                                lastName?: string | null | undefined;
+                                name?: string | null | undefined;
                             };
                             readonly output: {
-                                firstName?: string | null | undefined;
-                                lastName?: string | null | undefined;
+                                name?: string | null | undefined;
                             };
                             readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>;
                         } | undefined;
@@ -605,6 +607,11 @@ export declare const sync: {
                 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<{
+                readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<409, undefined>;
         }, undefined>, import("valibot").ObjectSchema<{
             readonly status: import("valibot").LiteralSchema<200, undefined>;
         }, undefined>], undefined>>;

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

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

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

@@ -258,8 +258,7 @@ export declare const pull: {
                 readonly value: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly settings: import("valibot").ObjectSchema<{
-                        readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                        readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     }, undefined>;
                 }, undefined>;
             }, undefined>], undefined>, undefined>;

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

@@ -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"}
+{"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/user.d.ts

@@ -32,8 +32,7 @@ export declare const syncPullUser: import("../../../../..").EndpointConfig<"/v1/
             readonly value: v.ObjectSchema<{
                 readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly settings: v.ObjectSchema<{
-                    readonly firstName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                    readonly lastName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 }, undefined>;
             }, undefined>;
         }, undefined>], undefined>, undefined>;

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

@@ -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"}
+{"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/push/account.d.ts

@@ -87,6 +87,11 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
         readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
     }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MUTATION_DRIFT", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;
 }, undefined>], undefined>>;

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

@@ -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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAyC1B,CAAA"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0C1B,CAAA"}

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

@@ -37,6 +37,7 @@ export const syncPushAccount = createEndpoint({
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,
+        errors.mutationDriftErrorSchema,
         v.object({ status: v.literal(200) }),
     ]),
 });

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

@@ -123,6 +123,11 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
         }, undefined>;
     }, undefined>;
     readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MUTATION_DRIFT", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;

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

@@ -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;AAM5B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAqDxB,CAAA"}
+{"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;AAM5B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAsDxB,CAAA"}

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

@@ -48,6 +48,7 @@ export const syncPushDraft = createEndpoint({
     path: draft.pushURL,
     response: v.union([
         errors.validationFailedErrorSchema,
+        errors.mutationDriftErrorSchema,
         errors.authFailedErrorSchema,
         v.object({ status: v.literal(200) }),
     ]),

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

@@ -87,6 +87,11 @@ export declare const push: {
             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<{
+            readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<409, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly status: import("valibot").LiteralSchema<200, undefined>;
     }, undefined>], undefined>>;
@@ -214,6 +219,11 @@ export declare const push: {
             }, undefined>;
         }, undefined>;
         readonly status: import("valibot").LiteralSchema<400, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<409, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly data: import("valibot").ObjectSchema<{
             readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
@@ -273,9 +283,9 @@ export declare const push: {
         readonly status: import("valibot").LiteralSchema<401, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+            readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
         }, undefined>;
-        readonly status: import("valibot").LiteralSchema<404, undefined>;
+        readonly status: import("valibot").LiteralSchema<409, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly status: import("valibot").LiteralSchema<200, undefined>;
     }, undefined>], undefined>>;
@@ -285,32 +295,25 @@ export declare const push: {
             readonly args: import("valibot").ObjectSchema<{
                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly settings: Omit<import("valibot").ObjectSchema<{
-                    readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                    readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                     readonly entries: {
-                        readonly firstName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                        readonly lastName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                        readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                     };
                     readonly '~standard': import("valibot").StandardSchemaProps<{
-                        firstName?: string | null | undefined;
-                        lastName?: string | null | undefined;
+                        name?: string | null | undefined;
                     }, {
-                        firstName?: string | null | undefined;
-                        lastName?: string | null | undefined;
+                        name?: string | null | undefined;
                     }>;
                     readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                        firstName?: string | null | undefined;
-                        lastName?: string | null | undefined;
+                        name?: string | null | undefined;
                     }, import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>>;
                     readonly '~types'?: {
                         readonly input: {
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         };
                         readonly output: {
-                            firstName?: string | null | undefined;
-                            lastName?: string | null | undefined;
+                            name?: string | null | undefined;
                         };
                         readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>;
                     } | undefined;
@@ -335,6 +338,11 @@ export declare const push: {
             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<{
+            readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<409, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly status: import("valibot").LiteralSchema<200, undefined>;
     }, undefined>], undefined>>;

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

@@ -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"}
+{"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

@@ -50,9 +50,9 @@ export declare const syncPushThread: import("../../../../..").EndpointConfig<"/v
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+        readonly code: v.LiteralSchema<"MUTATION_DRIFT", undefined>;
     }, undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;
 }, undefined>], undefined>>;

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

@@ -37,7 +37,7 @@ export const syncPushThread = createEndpoint({
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,
-        errors.messageNotFoundErrorSchema,
+        errors.mutationDriftErrorSchema,
         v.object({ status: v.literal(200) }),
     ]),
 });

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

@@ -5,32 +5,25 @@ export declare const syncPushUser: import("../../../../..").EndpointConfig<"/v1/
         readonly args: v.ObjectSchema<{
             readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly settings: Omit<v.ObjectSchema<{
-                readonly firstName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly lastName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                 readonly entries: {
-                    readonly firstName: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                    readonly lastName: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                    readonly name: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                 };
                 readonly '~standard': v.StandardSchemaProps<{
-                    firstName?: string | null | undefined;
-                    lastName?: string | null | undefined;
+                    name?: string | null | undefined;
                 }, {
-                    firstName?: string | null | undefined;
-                    lastName?: string | null | undefined;
+                    name?: string | null | undefined;
                 }>;
                 readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
-                    firstName?: string | null | undefined;
-                    lastName?: string | null | undefined;
+                    name?: string | null | undefined;
                 }, v.StringIssue | v.ObjectIssue | v.MaxLengthIssue<string, number>>;
                 readonly '~types'?: {
                     readonly input: {
-                        firstName?: string | null | undefined;
-                        lastName?: string | null | undefined;
+                        name?: string | null | undefined;
                     };
                     readonly output: {
-                        firstName?: string | null | undefined;
-                        lastName?: string | null | undefined;
+                        name?: string | null | undefined;
                     };
                     readonly issue: v.StringIssue | v.ObjectIssue | v.MaxLengthIssue<string, number>;
                 } | undefined;
@@ -55,6 +48,11 @@ export declare const syncPushUser: import("../../../../..").EndpointConfig<"/v1/
         readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
     }, undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MUTATION_DRIFT", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;
 }, undefined>], undefined>>;

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

@@ -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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAuBvB,CAAA"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAwBvB,CAAA"}

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

@@ -19,6 +19,7 @@ export const syncPushUser = createEndpoint({
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,
+        errors.mutationDriftErrorSchema,
         v.object({ status: v.literal(200) }),
     ]),
 });

package/dist/sdk/index.d.ts

@@ -280,8 +280,7 @@ export declare const marcoSDK: {
                                 readonly value: import("valibot").ObjectSchema<{
                                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly settings: import("valibot").ObjectSchema<{
-                                        readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                                        readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                        readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     }, undefined>;
                                 }, undefined>;
                             }, undefined>], undefined>, undefined>;
@@ -378,6 +377,11 @@ export declare const marcoSDK: {
                             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<{
+                            readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<409, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly status: import("valibot").LiteralSchema<200, undefined>;
                     }, undefined>], undefined>>;
@@ -505,6 +509,11 @@ export declare const marcoSDK: {
                             }, undefined>;
                         }, undefined>;
                         readonly status: import("valibot").LiteralSchema<400, undefined>;
+                    }, undefined>, import("valibot").ObjectSchema<{
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<409, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly data: import("valibot").ObjectSchema<{
                             readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
@@ -564,9 +573,9 @@ export declare const marcoSDK: {
                         readonly status: import("valibot").LiteralSchema<401, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly data: import("valibot").ObjectSchema<{
-                            readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                            readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
                         }, undefined>;
-                        readonly status: import("valibot").LiteralSchema<404, undefined>;
+                        readonly status: import("valibot").LiteralSchema<409, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly status: import("valibot").LiteralSchema<200, undefined>;
                     }, undefined>], undefined>>;
@@ -576,32 +585,25 @@ export declare const marcoSDK: {
                             readonly args: import("valibot").ObjectSchema<{
                                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly settings: Omit<import("valibot").ObjectSchema<{
-                                    readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                                    readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                                     readonly entries: {
-                                        readonly firstName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                                        readonly lastName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                                        readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                                     };
                                     readonly '~standard': import("valibot").StandardSchemaProps<{
-                                        firstName?: string | null | undefined;
-                                        lastName?: string | null | undefined;
+                                        name?: string | null | undefined;
                                     }, {
-                                        firstName?: string | null | undefined;
-                                        lastName?: string | null | undefined;
+                                        name?: string | null | undefined;
                                     }>;
                                     readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                                        firstName?: string | null | undefined;
-                                        lastName?: string | null | undefined;
+                                        name?: string | null | undefined;
                                     }, import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>>;
                                     readonly '~types'?: {
                                         readonly input: {
-                                            firstName?: string | null | undefined;
-                                            lastName?: string | null | undefined;
+                                            name?: string | null | undefined;
                                         };
                                         readonly output: {
-                                            firstName?: string | null | undefined;
-                                            lastName?: string | null | undefined;
+                                            name?: string | null | undefined;
                                         };
                                         readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, number>;
                                     } | undefined;
@@ -626,6 +628,11 @@ export declare const marcoSDK: {
                             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<{
+                            readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<409, undefined>;
                     }, undefined>, import("valibot").ObjectSchema<{
                         readonly status: import("valibot").LiteralSchema<200, undefined>;
                     }, undefined>], undefined>>;
@@ -811,6 +818,12 @@ export declare const marcoSDK: {
                 }, undefined>;
                 readonly status: import("valibot").LiteralSchema<404, undefined>;
             }, undefined>;
+            readonly mutationDriftErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<409, undefined>;
+            }, undefined>;
             readonly userNotFoundErrorSchema: import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;

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

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

@@ -47,6 +47,12 @@ export declare const messageNotFoundErrorSchema: v.ObjectSchema<{
     }, undefined>;
     readonly status: v.LiteralSchema<404, undefined>;
 }, undefined>;
+export declare const mutationDriftErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MUTATION_DRIFT", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>;
 export declare const validationFailedErrorSchema: v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
@@ -101,6 +107,12 @@ export declare const errors: {
         }, undefined>;
         readonly status: v.LiteralSchema<404, undefined>;
     }, undefined>;
+    readonly mutationDriftErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"MUTATION_DRIFT", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<409, undefined>;
+    }, undefined>;
     readonly userNotFoundErrorSchema: v.ObjectSchema<{
         readonly data: v.ObjectSchema<{
             readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;

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

@@ -1 +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"}
+{"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,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;aAUtC,CAAA;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWT,CAAA"}

package/dist/sdk/validation/errors.js

@@ -31,6 +31,10 @@ export const messageNotFoundErrorSchema = v.object({
     data: v.object({ code: v.literal('MESSAGE_NOT_FOUND') }),
     status: v.literal(404),
 });
+export const mutationDriftErrorSchema = v.object({
+    data: v.object({ code: v.literal('MUTATION_DRIFT') }),
+    status: v.literal(409),
+});
 export const validationFailedErrorSchema = v.object({
     data: v.object({
         code: v.literal('VALIDATION_FAILED'),
@@ -50,6 +54,7 @@ export const errors = {
     authServerResponseUnexpectedErrorSchema,
     authTooManyAttemptsErrorSchema,
     messageNotFoundErrorSchema,
+    mutationDriftErrorSchema,
     userNotFoundErrorSchema,
     validationFailedErrorSchema,
 };

package/dist/sdk/validation/index.d.ts

@@ -42,6 +42,12 @@ export declare const validation: {
             }, undefined>;
             readonly status: import("valibot").LiteralSchema<404, undefined>;
         }, undefined>;
+        readonly mutationDriftErrorSchema: import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"MUTATION_DRIFT", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<409, undefined>;
+        }, undefined>;
         readonly userNotFoundErrorSchema: import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;

package/dist/sdk/validation/index.d.ts.map

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

package/dist/types/SDKError.d.ts

@@ -1,4 +1,4 @@
 import * as v from 'valibot';
 import { errors } from '../sdk/validation/errors';
-export type SDKError = v.InferOutput<typeof errors.authCodeExpiredErrorSchema> | v.InferOutput<typeof errors.authCodePreviouslyUsedErrorSchema> | v.InferOutput<typeof errors.authRefreshTokenInvalid> | v.InferOutput<typeof errors.authServerResponseUnexpectedErrorSchema> | v.InferOutput<typeof errors.authTooManyAttemptsErrorSchema> | v.InferOutput<typeof errors.authFailedErrorSchema> | v.InferOutput<typeof errors.messageNotFoundErrorSchema> | v.InferOutput<typeof errors.userNotFoundErrorSchema> | v.InferOutput<typeof errors.validationFailedErrorSchema>;
+export type SDKError = v.InferOutput<typeof errors.authCodeExpiredErrorSchema> | v.InferOutput<typeof errors.authCodePreviouslyUsedErrorSchema> | v.InferOutput<typeof errors.authRefreshTokenInvalid> | v.InferOutput<typeof errors.authServerResponseUnexpectedErrorSchema> | v.InferOutput<typeof errors.authTooManyAttemptsErrorSchema> | v.InferOutput<typeof errors.authFailedErrorSchema> | v.InferOutput<typeof errors.messageNotFoundErrorSchema> | v.InferOutput<typeof errors.userNotFoundErrorSchema> | v.InferOutput<typeof errors.validationFailedErrorSchema> | v.InferOutput<typeof errors.mutationDriftErrorSchema>;
 //# sourceMappingURL=SDKError.d.ts.map

package/dist/types/SDKError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SDKError.d.ts","sourceRoot":"","sources":["../../src/types/SDKError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAA;AAE5D,MAAM,MAAM,QAAQ,GAChB,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uCAAuC,CAAC,GACpE,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,8BAA8B,CAAC,GAC3D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,qBAAqB,CAAC,GAClD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,CAAA"}
+{"version":3,"file":"SDKError.d.ts","sourceRoot":"","sources":["../../src/types/SDKError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAA;AAE5D,MAAM,MAAM,QAAQ,GAChB,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uCAAuC,CAAC,GACpE,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,8BAA8B,CAAC,GAC3D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,qBAAqB,CAAC,GAClD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GACxD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@marcoappio/marco-config",
   "packageManager": "bun@1.2.0",
-  "version": "2.0.206",
+  "version": "2.0.208",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",