@marcoappio/marco-config 2.0.441 → 2.0.443

package/dist/zero/index.d.ts

@@ -258,13 +258,10 @@ export declare const marcoZero: {
                 }, undefined>;
             };
             readonly requestAttachmentDownload: {
-                readonly delta: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly attachmentId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                    readonly threadId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
+                readonly delta: import("valibot").ObjectSchema<{
                     readonly attachmentIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                }, undefined>], undefined>;
+                }, undefined>;
             };
             readonly setArchive: {
                 readonly delta: import("valibot").ObjectSchema<{
@@ -272,13 +269,10 @@ export declare const marcoZero: {
                 }, undefined>;
             };
             readonly setFlagged: {
-                readonly delta: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly flagged: import("valibot").NonOptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-                    readonly threadId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
+                readonly delta: import("valibot").ObjectSchema<{
                     readonly flagged: import("valibot").NonOptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                }, undefined>], undefined>;
+                }, undefined>;
             };
             readonly setInbox: {
                 readonly delta: import("valibot").ObjectSchema<{

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/zero/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAIX,CAAC;mBACD,CAAC;oBAER,CAAJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAHK,CAAC;kBACD,CAAC;wBACI,CAAC;0BAEN,CAAC;4BAGD,CAAC;oBACH,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAM,CAAA;AAEV,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/zero/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAIX,CAAC;mBACD,CAAC;oBAER,CAAJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAHK,CAAC;kBACD,CAAC;wBACI,CAAC;0BAEN,CAAC;4BAGD,CAAC;oBACH,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAM,CAAA;AAEV,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA"}

package/dist/zero/mutatorSchemas/index.d.ts

@@ -256,13 +256,10 @@ export declare const zeroMutatorSchemas: {
             }, undefined>;
         };
         readonly requestAttachmentDownload: {
-            readonly delta: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                readonly attachmentId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly threadId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, import("valibot").ObjectSchema<{
+            readonly delta: import("valibot").ObjectSchema<{
                 readonly attachmentIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
                 readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
+            }, undefined>;
         };
         readonly setArchive: {
             readonly delta: import("valibot").ObjectSchema<{
@@ -270,13 +267,10 @@ export declare const zeroMutatorSchemas: {
             }, undefined>;
         };
         readonly setFlagged: {
-            readonly delta: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                readonly flagged: import("valibot").NonOptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-                readonly threadId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, import("valibot").ObjectSchema<{
+            readonly delta: import("valibot").ObjectSchema<{
                 readonly flagged: import("valibot").NonOptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
                 readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
+            }, undefined>;
         };
         readonly setInbox: {
             readonly delta: import("valibot").ObjectSchema<{

package/dist/zero/mutatorSchemas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zero/mutatorSchemas/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKrB,CAAA;AAEV,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zero/mutatorSchemas/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKrB,CAAA;AAEV,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA"}

package/dist/zero/mutatorSchemas/thread.d.ts

@@ -18,13 +18,10 @@ export declare const threadMutatorSchemas: {
         }, undefined>;
     };
     readonly requestAttachmentDownload: {
-        readonly delta: v.UnionSchema<[v.ObjectSchema<{
-            readonly attachmentId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
+        readonly delta: v.ObjectSchema<{
             readonly attachmentIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
             readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
+        }, undefined>;
     };
     readonly setArchive: {
         readonly delta: v.ObjectSchema<{
@@ -32,13 +29,10 @@ export declare const threadMutatorSchemas: {
         }, undefined>;
     };
     readonly setFlagged: {
-        readonly delta: v.UnionSchema<[v.ObjectSchema<{
-            readonly flagged: v.NonOptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
+        readonly delta: v.ObjectSchema<{
             readonly flagged: v.NonOptionalSchema<v.BooleanSchema<undefined>, undefined>;
             readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
+        }, undefined>;
     };
     readonly setInbox: {
         readonly delta: v.ObjectSchema<{

package/dist/zero/mutatorSchemas/thread.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../../src/zero/mutatorSchemas/thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAwC5B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BvB,CAAA"}
+{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../../src/zero/mutatorSchemas/thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCvB,CAAA"}

package/dist/zero/mutatorSchemas/thread.js

@@ -7,30 +7,6 @@ const threadAddRemoveLabelSchema = v.object({
     labelPath: marcoSchemas.string.required(),
     threadIds: v.array(marcoSchemas.string.required()),
 });
-const threadRequestAttachmentSchema = v.union([
-    v.object({
-        attachmentId: marcoSchemas.string.required(),
-        threadId: marcoSchemas.string.required(),
-    }),
-    v.object({
-        attachmentIds: v.array(marcoSchemas.string.required()),
-        threadIds: v.array(marcoSchemas.string.required()),
-    }),
-]);
-const threadSetFlaggedSchema = v.union([
-    v.object({
-        flagged: v.nonOptional(v.boolean()),
-        threadId: marcoSchemas.string.required(),
-    }),
-    v.object({
-        flagged: v.nonOptional(v.boolean()),
-        threadIds: v.array(marcoSchemas.string.required()),
-    }),
-]);
-const threadSetSeenSchema = v.object({
-    seen: v.boolean(),
-    threadIds: v.array(marcoSchemas.string.required()),
-});
 export const threadMutatorSchemas = {
     addLabel: {
         delta: threadAddRemoveLabelSchema,
@@ -42,19 +18,28 @@ export const threadMutatorSchemas = {
         delta: threadAddRemoveLabelSchema,
     },
     requestAttachmentDownload: {
-        delta: threadRequestAttachmentSchema,
+        delta: v.object({
+            attachmentIds: v.array(marcoSchemas.string.required()),
+            threadIds: v.array(marcoSchemas.string.required()),
+        }),
     },
     setArchive: {
         delta: threadIdsSchema,
     },
     setFlagged: {
-        delta: threadSetFlaggedSchema,
+        delta: v.object({
+            flagged: v.nonOptional(v.boolean()),
+            threadIds: v.array(marcoSchemas.string.required()),
+        }),
     },
     setInbox: {
         delta: threadIdsSchema,
     },
     setSeen: {
-        delta: threadSetSeenSchema,
+        delta: v.object({
+            seen: v.boolean(),
+            threadIds: v.array(marcoSchemas.string.required()),
+        }),
     },
     setSpam: {
         delta: threadIdsSchema,

package/dist/zero/mutators/accountMutators/accountMutators.js

@@ -21,7 +21,7 @@ export const createAccountMutators = (authData, callbacks) => ({
             isPrimary: true,
             name: null,
         });
-        await callbacks?.createAccount?.(args);
+        callbacks?.createAccount?.(args);
     },
     createAlias: async (tx, args) => {
         await tx.mutate.accountAlias.insert({
@@ -31,13 +31,13 @@ export const createAccountMutators = (authData, callbacks) => ({
             isPrimary: false,
             name: args.alias.name ?? null,
         });
-        await callbacks?.createAlias?.(args);
+        callbacks?.createAlias?.(args);
     },
     deleteAccount: async (tx, args) => {
         await tx.mutate.account.delete({
             id: args.id,
         });
-        await callbacks?.deleteAccount?.(args);
+        callbacks?.deleteAccount?.(args);
     },
     deleteAlias: async (tx, args) => {
         const alias = await tx.query.accountAlias.where('id', args.aliasId).one().run();
@@ -64,14 +64,14 @@ export const createAccountMutators = (authData, callbacks) => ({
                 });
             }
         }
-        await callbacks?.deleteAlias?.(args);
+        callbacks?.deleteAlias?.(args);
     },
     setAliasName: async (tx, args) => {
         await tx.mutate.accountAlias.update({
             id: args.aliasId,
             name: args.displayName,
         });
-        await callbacks?.setAliasName?.(args);
+        callbacks?.setAliasName?.(args);
     },
     setAliasPrimary: async (tx, args) => {
         const aliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
@@ -85,21 +85,21 @@ export const createAccountMutators = (authData, callbacks) => ({
             id: args.accountId,
             primaryAliasId: args.aliasId,
         });
-        await callbacks?.setAliasPrimary?.(args);
+        callbacks?.setAliasPrimary?.(args);
     },
     setConnectionConfigImapRaw: async (tx, args) => {
         await tx.mutate.account.update({
             id: args.id,
             imapConnectionStatus: 'AWAITING_CONNECTION',
         });
-        await callbacks?.setConnectionConfigImapRaw?.(args);
+        callbacks?.setConnectionConfigImapRaw?.(args);
     },
     setConnectionConfigOauth: async (tx, args) => {
         await tx.mutate.account.update({
             id: args.id,
             imapConnectionStatus: 'AWAITING_CONNECTION',
         });
-        await callbacks?.setConnectionConfigOauth?.(args);
+        callbacks?.setConnectionConfigOauth?.(args);
     },
     setSettings: async (tx, args) => {
         await tx.mutate.account.update({
@@ -107,6 +107,6 @@ export const createAccountMutators = (authData, callbacks) => ({
             displayName: args.displayName ? args.displayName : undefined,
             id: args.id,
         });
-        await callbacks?.setSettings?.(args);
+        callbacks?.setSettings?.(args);
     },
 });

package/dist/zero/mutators/accountMutators/accountMutators.test.js

@@ -5,7 +5,7 @@ describe('accountMutators', () => {
         it('creates an account and invokes the callback', async () => {
             const accountInsert = mock(async () => { });
             const accountAliasInsert = mock(async () => { });
-            const createAccountCallback = mock(async () => { });
+            const createAccountCallback = mock(() => { });
             const mutators = createMutators({ sub: 'test-user-id' }, {
                 account: {
                     createAccount: createAccountCallback,
@@ -69,7 +69,7 @@ describe('accountMutators', () => {
     describe('createAlias', () => {
         it('creates an alias', async () => {
             const accountAliasInsert = mock(async () => { });
-            const createAliasCallback = mock(async () => { });
+            const createAliasCallback = mock(() => { });
             const mutators = createMutators({ sub: 'test-user-id' }, {
                 account: {
                     createAlias: createAliasCallback,
@@ -106,7 +106,7 @@ describe('accountMutators', () => {
     describe('deleteAccount', () => {
         it('deletes an account', async () => {
             const accountDelete = mock(async () => { });
-            const deleteAccountCallback = mock(async () => { });
+            const deleteAccountCallback = mock(() => { });
             const mutators = createMutators({ sub: 'test-user-id' }, {
                 account: {
                     deleteAccount: deleteAccountCallback,

package/dist/zero/mutators/draftMutators/draftMutators.js

@@ -8,7 +8,7 @@ export const createDraftMutators = (authData, callbacks) => ({
             status: 'DRAFT',
             updatedAt: args.updatedAt,
         });
-        await callbacks?.cancelSend?.(args);
+        callbacks?.cancelSend?.(args);
     },
     createAttachment: async (tx, args) => {
         await tx.mutate.draftAttachment.insert({
@@ -25,7 +25,7 @@ export const createDraftMutators = (authData, callbacks) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-        await callbacks?.createAttachment?.(args);
+        callbacks?.createAttachment?.(args);
     },
     createDraft: async (tx, args) => {
         if (!authData) {
@@ -64,7 +64,7 @@ export const createDraftMutators = (authData, callbacks) => ({
                 uploadedChunks: attachment.uploadedChunks,
             });
         }
-        await callbacks?.createDraft?.(args);
+        callbacks?.createDraft?.(args);
     },
     deleteAttachment: async (tx, args) => {
         await tx.mutate.draftAttachment.delete({
@@ -74,13 +74,13 @@ export const createDraftMutators = (authData, callbacks) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-        await callbacks?.deleteAttachment?.(args);
+        callbacks?.deleteAttachment?.(args);
     },
     deleteDraft: async (tx, args) => {
         await tx.mutate.draft.delete({
             id: args.id,
         });
-        await callbacks?.deleteDraft?.(args);
+        callbacks?.deleteDraft?.(args);
     },
     scheduleSend: async (tx, args) => {
         if (args.kind === 'IMMEDIATE') {
@@ -99,7 +99,7 @@ export const createDraftMutators = (authData, callbacks) => ({
                 updatedAt: args.updatedAt,
             });
         }
-        await callbacks?.scheduleSend?.(args);
+        callbacks?.scheduleSend?.(args);
     },
     setContent: async (tx, args) => {
         const draft = await tx.query.draft.where('id', args.id).one().run();
@@ -116,7 +116,7 @@ export const createDraftMutators = (authData, callbacks) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-        await callbacks?.setContent?.(args);
+        callbacks?.setContent?.(args);
     },
     setEnvelope: async (tx, args) => {
         const draft = await tx.query.draft.where('id', args.id).one().run();
@@ -134,7 +134,7 @@ export const createDraftMutators = (authData, callbacks) => ({
             subject: args.envelope.subject,
             updatedAt: args.updatedAt,
         });
-        await callbacks?.setEnvelope?.(args);
+        callbacks?.setEnvelope?.(args);
     },
     setFrom: async (tx, args) => {
         await tx.mutate.draft.update({
@@ -145,7 +145,7 @@ export const createDraftMutators = (authData, callbacks) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-        await callbacks?.setFrom?.(args);
+        callbacks?.setFrom?.(args);
     },
     uploadAttachmentChunk: async (tx, args) => {
         const attachment = await tx.query.draftAttachment.where('id', args.attachmentId).one().run();
@@ -157,6 +157,6 @@ export const createDraftMutators = (authData, callbacks) => ({
             id: args.attachmentId,
             uploadedChunks,
         });
-        await callbacks?.uploadAttachmentChunk?.(args);
+        callbacks?.uploadAttachmentChunk?.(args);
     },
 });

package/dist/zero/mutators/threadMutators/threadMutators.d.ts

@@ -1,8 +1,10 @@
 import type * as v from 'valibot';
+import type { LabelSpecialUse } from '../../../types';
 import { type AuthData, type HandlerMap } from '../../../types';
 import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
 export type ThreadMutatorCallbacks = {
     [K in keyof ZeroMutatorSchemas['thread']]?: (args: v.InferOutput<ZeroMutatorSchemas['thread'][K]['delta']>) => Promise<void>;
 };
+export declare const setSystemLabel: (tx: any, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<void>;
 export declare const createThreadMutators: (_authData: AuthData | undefined, callbacks?: ThreadMutatorCallbacks) => HandlerMap<ZeroMutatorSchemas["thread"]>;
 //# sourceMappingURL=threadMutators.d.ts.map

package/dist/zero/mutators/threadMutators/threadMutators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,MAAM,MAAM,sBAAsB,GAAG;KAClC,CAAC,IAAI,MAAM,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAC1C,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAC1D,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAED,eAAO,MAAM,oBAAoB,cACpB,QAAQ,GAAG,SAAS,cACnB,sBAAsB,KACjC,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CA8RxC,CAAA"}
+{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,MAAM,MAAM,sBAAsB,GAAG;KAClC,CAAC,IAAI,MAAM,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAC1C,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAC1D,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAED,eAAO,MAAM,cAAc,OAAc,GAAG,YAAY,MAAM,oBAAoB,eAAe,KAAG,OAAO,CAAC,IAAI,CAwC/G,CAAA;AAED,eAAO,MAAM,oBAAoB,cACpB,QAAQ,GAAG,SAAS,cACnB,sBAAsB,KACjC,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAwIxC,CAAA"}

package/dist/zero/mutators/threadMutators/threadMutators.js

@@ -1,4 +1,38 @@
 import { MutationError } from '../../../types';
+export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
+    const thread = await tx.query.thread.where('id', threadId).one().run();
+    if (!thread) {
+        throw new Error(MutationError.ENTITY_NOT_FOUND);
+    }
+    const { accountId } = thread;
+    const targetLabel = await tx.query.accountLabel
+        .where('accountId', accountId)
+        .where('specialUse', targetSpecialUse)
+        .one()
+        .run();
+    if (!targetLabel) {
+        throw new Error(MutationError.ENTITY_NOT_FOUND);
+    }
+    const allThreadLabels = await tx.query.threadLabel.where('threadId', threadId).run();
+    let hasTarget = false;
+    for (const label of allThreadLabels) {
+        if (label.labelId === targetLabel.id) {
+            hasTarget = true;
+        }
+        else {
+            await tx.mutate.threadLabel.delete({
+                labelId: label.labelId,
+                threadId,
+            });
+        }
+    }
+    if (!hasTarget) {
+        await tx.mutate.threadLabel.insert({
+            labelId: targetLabel.id,
+            threadId,
+        });
+    }
+};
 export const createThreadMutators = (_authData, callbacks) => ({
     addLabel: async (tx, args) => {
         for (const threadId of args.threadIds) {
@@ -22,7 +56,7 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 });
             }
         }
-        await callbacks?.addLabel?.(args);
+        callbacks?.addLabel?.(args);
     },
     delete: async (tx, args) => {
         for (const threadId of args.threadIds) {
@@ -30,7 +64,7 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 id: threadId,
             });
         }
-        await callbacks?.delete?.(args);
+        callbacks?.delete?.(args);
     },
     removeLabel: async (tx, args) => {
         for (const threadId of args.threadIds) {
@@ -55,11 +89,10 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 threadId,
             });
         }
-        await callbacks?.removeLabel?.(args);
+        callbacks?.removeLabel?.(args);
     },
     requestAttachmentDownload: async (tx, args) => {
-        const attachmentIds = 'attachmentIds' in args ? args.attachmentIds : [args.attachmentId];
-        for (const attachmentId of attachmentIds) {
+        for (const attachmentId of args.attachmentIds) {
             const attachment = await tx.query.threadMessageAttachment.where('id', attachmentId).one().run();
             if (!attachment) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -68,111 +101,29 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 id: attachmentId,
                 status: 'DOWNLOAD_REQUESTED',
             });
-            await callbacks?.requestAttachmentDownload?.(args);
+            callbacks?.requestAttachmentDownload?.(args);
         }
     },
     setArchive: async (tx, args) => {
         for (const threadId of args.threadIds) {
-            const thread = await tx.query.thread.where('id', threadId).one().run();
-            if (!thread) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
-            }
-            const inboxLabel = await tx.query.accountLabel
-                .where('accountId', thread.accountId)
-                .where('specialUse', 'INBOX')
-                .one()
-                .run();
-            const archiveLabel = await tx.query.accountLabel
-                .where('accountId', thread.accountId)
-                .where('specialUse', 'ARCHIVE')
-                .one()
-                .run();
-            if (!inboxLabel || !archiveLabel) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
-            }
-            if (inboxLabel) {
-                const existing = await tx.query.threadLabel
-                    .where('threadId', threadId)
-                    .where('labelId', inboxLabel.id)
-                    .one()
-                    .run();
-                if (existing) {
-                    await tx.mutate.threadLabel.delete({
-                        labelId: inboxLabel.id,
-                        threadId,
-                    });
-                }
-            }
-            if (archiveLabel) {
-                const existing = await tx.query.threadLabel
-                    .where('threadId', threadId)
-                    .where('labelId', archiveLabel.id)
-                    .one()
-                    .run();
-                if (!existing) {
-                    await tx.mutate.threadLabel.insert({
-                        labelId: archiveLabel.id,
-                        threadId,
-                    });
-                }
-            }
+            await setSystemLabel(tx, threadId, 'ARCHIVE');
         }
-        await callbacks?.setArchive?.(args);
+        callbacks?.setArchive?.(args);
     },
     setFlagged: async (tx, args) => {
-        const threadIds = 'threadId' in args ? [args.threadId] : args.threadIds;
-        for (const threadId of threadIds) {
+        for (const threadId of args.threadIds) {
             await tx.mutate.thread.update({
                 flagged: args.flagged,
                 id: threadId,
             });
         }
-        await callbacks?.setFlagged?.(args);
+        callbacks?.setFlagged?.(args);
     },
     setInbox: async (tx, args) => {
         for (const threadId of args.threadIds) {
-            const thread = await tx.query.thread.where('id', threadId).one().run();
-            if (!thread) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
-            }
-            const inboxLabel = await tx.query.accountLabel
-                .where('accountId', thread.accountId)
-                .where('specialUse', 'INBOX')
-                .one()
-                .run();
-            const archiveLabel = await tx.query.accountLabel
-                .where('accountId', thread.accountId)
-                .where('specialUse', 'ARCHIVE')
-                .one()
-                .run();
-            if (archiveLabel) {
-                const existing = await tx.query.threadLabel
-                    .where('threadId', threadId)
-                    .where('labelId', archiveLabel.id)
-                    .one()
-                    .run();
-                if (existing) {
-                    await tx.mutate.threadLabel.delete({
-                        labelId: archiveLabel.id,
-                        threadId,
-                    });
-                }
-            }
-            if (inboxLabel) {
-                const existing = await tx.query.threadLabel
-                    .where('threadId', threadId)
-                    .where('labelId', inboxLabel.id)
-                    .one()
-                    .run();
-                if (!existing) {
-                    await tx.mutate.threadLabel.insert({
-                        labelId: inboxLabel.id,
-                        threadId,
-                    });
-                }
-            }
+            await setSystemLabel(tx, threadId, 'INBOX');
         }
-        await callbacks?.setInbox?.(args);
+        callbacks?.setInbox?.(args);
     },
     setSeen: async (tx, args) => {
         for (const threadId of args.threadIds) {
@@ -181,58 +132,18 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 seen: args.seen,
             });
         }
-        await callbacks?.setSeen?.(args);
+        callbacks?.setSeen?.(args);
     },
     setSpam: async (tx, args) => {
         for (const threadId of args.threadIds) {
-            const thread = await tx.query.thread.where('id', threadId).one().run();
-            if (!thread) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
-            }
-            const spamLabel = await tx.query.accountLabel
-                .where('accountId', thread.accountId)
-                .where('specialUse', 'SPAM')
-                .one()
-                .run();
-            if (!spamLabel) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
-            }
-            const existing = await tx.query.threadLabel.where('threadId', threadId).where('labelId', spamLabel.id).one().run();
-            if (!existing) {
-                await tx.mutate.threadLabel.insert({
-                    labelId: spamLabel.id,
-                    threadId,
-                });
-            }
+            await setSystemLabel(tx, threadId, 'SPAM');
         }
-        await callbacks?.setSpam?.(args);
+        callbacks?.setSpam?.(args);
     },
     setTrash: async (tx, args) => {
         for (const threadId of args.threadIds) {
-            const thread = await tx.query.thread.where('id', threadId).one().run();
-            if (!thread) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
-            }
-            const trashLabel = await tx.query.accountLabel
-                .where('accountId', thread.accountId)
-                .where('specialUse', 'TRASH')
-                .one()
-                .run();
-            if (!trashLabel) {
-                throw new Error(MutationError.ENTITY_NOT_FOUND);
-            }
-            const existing = await tx.query.threadLabel
-                .where('threadId', threadId)
-                .where('labelId', trashLabel.id)
-                .one()
-                .run();
-            if (!existing) {
-                await tx.mutate.threadLabel.insert({
-                    labelId: trashLabel.id,
-                    threadId,
-                });
-            }
+            await setSystemLabel(tx, threadId, 'TRASH');
         }
-        await callbacks?.setTrash?.(args);
+        callbacks?.setTrash?.(args);
     },
 });

package/dist/zero/mutators/threadMutators/threadMutators.test.js

@@ -158,8 +158,8 @@ describe('threadMutators', () => {
             };
             const mutators = createMutators();
             await mutators.thread.requestAttachmentDownload(transaction, {
-                attachmentId: 'test-attachment-id-1',
-                threadId: 'test-thread-id-1',
+                attachmentIds: ['test-attachment-id-1'],
+                threadIds: ['test-thread-id-1'],
             });
             expect(attachmentUpdate).toHaveBeenCalledWith({
                 id: 'test-attachment-id-1',
@@ -169,17 +169,10 @@ describe('threadMutators', () => {
     });
     describe('setArchive', () => {
         it('archives thread', async () => {
-            let labelQueryCount = 0;
-            let threadLabelQueryCount = 0;
             const threadRecord = {
                 accountId: 'test-account-id-1',
                 id: 'test-thread-id-1',
             };
-            const inboxLabel = {
-                accountId: 'test-account-id-1',
-                id: 'test-inbox-label-id',
-                specialUse: 'INBOX',
-            };
             const archiveLabel = {
                 accountId: 'test-account-id-1',
                 id: 'test-archive-label-id',
@@ -188,22 +181,12 @@ describe('threadMutators', () => {
             const runThread = mock(async () => threadRecord);
             const oneThread = mock(() => ({ run: runThread }));
             const whereThread = mock(() => ({ one: oneThread }));
-            const runLabel = mock(async () => {
-                const result = labelQueryCount === 0 ? inboxLabel : archiveLabel;
-                labelQueryCount++;
-                return result;
-            });
+            const runLabel = mock(async () => archiveLabel);
             const oneLabel = mock(() => ({ run: runLabel }));
             const whereSpecialUse = mock(() => ({ one: oneLabel }));
             const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
-            const runExisting = mock(async () => {
-                const result = threadLabelQueryCount === 0 ? { labelId: 'test-inbox-label-id' } : null;
-                threadLabelQueryCount++;
-                return result;
-            });
-            const oneExisting = mock(() => ({ run: runExisting }));
-            const whereLabel = mock(() => ({ one: oneExisting }));
-            const whereThreadLabel = mock(() => ({ where: whereLabel }));
+            const runAllThreadLabels = mock(async () => [{ labelId: 'test-inbox-label-id', threadId: 'test-thread-id-1' }]);
+            const whereThreadLabel = mock(() => ({ run: runAllThreadLabels }));
             const threadLabelDelete = mock(async () => { });
             const threadLabelInsert = mock(async () => { });
             const transaction = {
@@ -253,7 +236,7 @@ describe('threadMutators', () => {
             const mutators = createMutators();
             await mutators.thread.setFlagged(transaction, {
                 flagged: true,
-                threadId: 'test-thread-id-1',
+                threadIds: ['test-thread-id-1'],
             });
             expect(threadUpdate).toHaveBeenCalledWith({
                 flagged: true,
@@ -263,8 +246,6 @@ describe('threadMutators', () => {
     });
     describe('setInbox', () => {
         it('moves thread to inbox', async () => {
-            let labelQueryCount = 0;
-            let threadLabelQueryCount = 0;
             const threadRecord = {
                 accountId: 'test-account-id-1',
                 id: 'test-thread-id-1',
@@ -274,30 +255,15 @@ describe('threadMutators', () => {
                 id: 'test-inbox-label-id',
                 specialUse: 'INBOX',
             };
-            const archiveLabel = {
-                accountId: 'test-account-id-1',
-                id: 'test-archive-label-id',
-                specialUse: 'ARCHIVE',
-            };
             const runThread = mock(async () => threadRecord);
             const oneThread = mock(() => ({ run: runThread }));
             const whereThread = mock(() => ({ one: oneThread }));
-            const runLabel = mock(async () => {
-                const result = labelQueryCount === 0 ? inboxLabel : archiveLabel;
-                labelQueryCount++;
-                return result;
-            });
+            const runLabel = mock(async () => inboxLabel);
             const oneLabel = mock(() => ({ run: runLabel }));
             const whereSpecialUse = mock(() => ({ one: oneLabel }));
             const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
-            const runExisting = mock(async () => {
-                const result = threadLabelQueryCount === 0 ? { labelId: 'test-archive-label-id' } : null;
-                threadLabelQueryCount++;
-                return result;
-            });
-            const oneExisting = mock(() => ({ run: runExisting }));
-            const whereLabel = mock(() => ({ one: oneExisting }));
-            const whereThreadLabel = mock(() => ({ where: whereLabel }));
+            const runAllThreadLabels = mock(async () => [{ labelId: 'test-archive-label-id', threadId: 'test-thread-id-1' }]);
+            const whereThreadLabel = mock(() => ({ run: runAllThreadLabels }));
             const threadLabelDelete = mock(async () => { });
             const threadLabelInsert = mock(async () => { });
             const transaction = {
@@ -378,10 +344,8 @@ describe('threadMutators', () => {
             const oneLabel = mock(() => ({ run: runSpam }));
             const whereSpecialUse = mock(() => ({ one: oneLabel }));
             const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
-            const runExisting = mock(async () => null);
-            const oneExisting = mock(() => ({ run: runExisting }));
-            const whereLabel = mock(() => ({ one: oneExisting }));
-            const whereThreadLabel = mock(() => ({ where: whereLabel }));
+            const runAllThreadLabels = mock(async () => []);
+            const whereThreadLabel = mock(() => ({ run: runAllThreadLabels }));
             const threadLabelInsert = mock(async () => { });
             const transaction = {
                 mutate: {
@@ -429,10 +393,8 @@ describe('threadMutators', () => {
             const oneLabel = mock(() => ({ run: runTrash }));
             const whereSpecialUse = mock(() => ({ one: oneLabel }));
             const whereLabelAccount = mock(() => ({ where: whereSpecialUse }));
-            const runExisting = mock(async () => null);
-            const oneExisting = mock(() => ({ run: runExisting }));
-            const whereLabel = mock(() => ({ one: oneExisting }));
-            const whereThreadLabel = mock(() => ({ where: whereLabel }));
+            const runAllThreadLabels = mock(async () => []);
+            const whereThreadLabel = mock(() => ({ run: runAllThreadLabels }));
             const threadLabelInsert = mock(async () => { });
             const transaction = {
                 mutate: {

package/dist/zero/mutators/userMutators/userMutators.js

@@ -3,14 +3,14 @@ export const createUserMutators = (_authData, callbacks) => ({
         await tx.mutate.userPushNotificationToken.delete({
             id: args.id,
         });
-        await callbacks?.deleteSettingsPushNotificationToken?.(args);
+        callbacks?.deleteSettingsPushNotificationToken?.(args);
     },
     setSettingsName: async (tx, args) => {
         await tx.mutate.user.update({
             id: args.id,
             name: args.name,
         });
-        await callbacks?.setSettingsName?.(args);
+        callbacks?.setSettingsName?.(args);
     },
     setSettingsPushNotificationToken: async (tx, args) => {
         const existing = await tx.query.userPushNotificationToken
@@ -25,7 +25,7 @@ export const createUserMutators = (_authData, callbacks) => ({
                 token: args.pushNotificationToken.token,
                 userId: args.id,
             });
-            await callbacks?.setSettingsPushNotificationToken?.(args);
+            callbacks?.setSettingsPushNotificationToken?.(args);
         }
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "2.0.441",
+  "version": "2.0.443",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",