@marcoappio/marco-config 2.0.451 → 2.0.453

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/draft.d.ts

@@ -13,9 +13,8 @@ export declare const draftMutatorSchemas: {
                 readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly totalChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly status: v.PicklistSchema<readonly ["PENDING", "COMPLETE", "FAILED"], undefined>;
                 readonly totalSize: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                readonly uploadedChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
             }, undefined>;
             readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
@@ -29,9 +28,8 @@ export declare const draftMutatorSchemas: {
                 readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly totalChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly status: v.PicklistSchema<readonly ["PENDING", "COMPLETE", "FAILED"], undefined>;
                 readonly totalSize: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                readonly uploadedChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
             }, undefined>, undefined>;
             readonly body: v.ObjectSchema<{
                 readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
@@ -150,13 +148,5 @@ export declare const draftMutatorSchemas: {
             readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         }, undefined>;
     };
-    readonly uploadAttachmentChunk: {
-        readonly delta: v.ObjectSchema<{
-            readonly attachmentId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly chunk: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
-            readonly chunkIndex: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>;
-    };
 };
 //# sourceMappingURL=draft.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../../src/zero/mutatorSchemas/draft.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAwD5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEtB,CAAA"}
+{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../../src/zero/mutatorSchemas/draft.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAuD5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDtB,CAAA"}

package/dist/zero/mutatorSchemas/draft.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../../schemas';
-import { DRAFT_STATUSES, DRAFT_TYPES } from '../../types';
+import { DRAFT_ATTACHMENT_UPLOAD_STATUSES, DRAFT_STATUSES, DRAFT_TYPES } from '../../types';
 const draftStatusSchema = v.picklist(DRAFT_STATUSES);
 const draftTypeSchema = v.picklist(DRAFT_TYPES);
 const draftBodySchema = v.object({
@@ -15,9 +15,8 @@ const draftAttachmentSchema = v.object({
     fileName: marcoSchemas.string.required(),
     id: marcoSchemas.string.required(),
     mimeType: marcoSchemas.string.required(),
-    totalChunks: marcoSchemas.number.positiveInteger(),
+    status: v.picklist(DRAFT_ATTACHMENT_UPLOAD_STATUSES),
     totalSize: marcoSchemas.number.positiveInteger(),
-    uploadedChunks: marcoSchemas.number.positiveInteger(),
 });
 const draftScheduleSchema = v.union([
     v.object({
@@ -103,12 +102,4 @@ export const draftMutatorSchemas = {
             updatedAt: marcoSchemas.number.positiveInteger(),
         }),
     },
-    uploadAttachmentChunk: {
-        delta: v.object({
-            attachmentId: marcoSchemas.string.required(),
-            chunk: v.pipe(v.string(), v.base64()),
-            chunkIndex: marcoSchemas.number.positiveInteger(),
-            id: marcoSchemas.string.required(),
-        }),
-    },
 };

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

@@ -91,9 +91,8 @@ export declare const zeroMutatorSchemas: {
                     readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly mimeType: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                    readonly totalChunks: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly status: import("valibot").PicklistSchema<readonly ["PENDING", "COMPLETE", "FAILED"], undefined>;
                     readonly totalSize: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                    readonly uploadedChunks: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                 }, undefined>;
                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
@@ -107,9 +106,8 @@ export declare const zeroMutatorSchemas: {
                     readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly mimeType: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                    readonly totalChunks: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly status: import("valibot").PicklistSchema<readonly ["PENDING", "COMPLETE", "FAILED"], undefined>;
                     readonly totalSize: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                    readonly uploadedChunks: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                 }, undefined>, undefined>;
                 readonly body: import("valibot").ObjectSchema<{
                     readonly bcc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
@@ -228,14 +226,6 @@ export declare const zeroMutatorSchemas: {
                 readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
             }, undefined>;
         };
-        readonly uploadAttachmentChunk: {
-            readonly delta: 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 chunk: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").Base64Action<string, undefined>]>;
-                readonly chunkIndex: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                readonly id: 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 thread: {
         readonly addLabel: {

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/mutators/draftMutators/draftMutators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,MAAM,MAAM,qBAAqB,GAAG;KACjC,CAAC,IAAI,MAAM,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CACzC,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KACzD,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAED,eAAO,MAAM,mBAAmB,aACpB,QAAQ,GAAG,SAAS,cAClB,qBAAqB,KAChC,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAwLvC,CAAA"}
+{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,MAAM,MAAM,qBAAqB,GAAG;KACjC,CAAC,IAAI,MAAM,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CACzC,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KACzD,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAED,eAAO,MAAM,mBAAmB,aACpB,QAAQ,GAAG,SAAS,cAClB,qBAAqB,KAChC,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAmKvC,CAAA"}

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

@@ -17,9 +17,8 @@ export const createDraftMutators = (authData, callbacks) => ({
             fileName: args.attachment.fileName,
             id: args.attachment.id,
             mimeType: args.attachment.mimeType,
-            totalChunks: args.attachment.totalChunks,
+            status: args.attachment.status,
             totalSize: args.attachment.totalSize,
-            uploadedChunks: args.attachment.uploadedChunks,
         });
         await tx.mutate.draft.update({
             id: args.id,
@@ -59,9 +58,8 @@ export const createDraftMutators = (authData, callbacks) => ({
                 fileName: attachment.fileName,
                 id: attachment.id,
                 mimeType: attachment.mimeType,
-                totalChunks: attachment.totalChunks,
+                status: attachment.status,
                 totalSize: attachment.totalSize,
-                uploadedChunks: attachment.uploadedChunks,
             });
         }
         callbacks?.createDraft?.(args);
@@ -147,16 +145,4 @@ export const createDraftMutators = (authData, callbacks) => ({
         });
         callbacks?.setFrom?.(args);
     },
-    uploadAttachmentChunk: async (tx, args) => {
-        const attachment = await tx.query.draftAttachment.where('id', args.attachmentId).one().run();
-        if (!attachment) {
-            throw new Error(MutationError.ENTITY_NOT_FOUND);
-        }
-        const uploadedChunks = Math.max(typeof attachment.uploadedChunks === 'number' ? attachment.uploadedChunks : 0, args.chunkIndex + 1);
-        await tx.mutate.draftAttachment.update({
-            id: args.attachmentId,
-            uploadedChunks,
-        });
-        callbacks?.uploadAttachmentChunk?.(args);
-    },
 });

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

@@ -127,9 +127,8 @@ describe('draftMutators', () => {
                     fileName: 'test-document.pdf',
                     id: 'test-attachment-id-1',
                     mimeType: 'application/pdf',
-                    totalChunks: 5,
+                    status: 'PENDING',
                     totalSize: 1024000,
-                    uploadedChunks: 0,
                 },
                 id: 'test-draft-id-1',
                 updatedAt: 3_000,
@@ -140,9 +139,8 @@ describe('draftMutators', () => {
                 fileName: 'test-document.pdf',
                 id: 'test-attachment-id-1',
                 mimeType: 'application/pdf',
-                totalChunks: 5,
+                status: 'PENDING',
                 totalSize: 1024000,
-                uploadedChunks: 0,
             });
             expect(draftUpdate).toHaveBeenCalledWith({
                 id: 'test-draft-id-1',
@@ -350,41 +348,4 @@ describe('draftMutators', () => {
             });
         });
     });
-    describe('uploadAttachmentChunk', () => {
-        it('uploads attachment chunk', async () => {
-            const attachmentRecord = {
-                id: 'test-attachment-id-1',
-                uploadedChunks: 2,
-            };
-            const run = mock(async () => attachmentRecord);
-            const one = mock(() => ({ run }));
-            const where = mock(() => ({ one }));
-            const draftAttachmentUpdate = mock(async () => { });
-            const transaction = {
-                mutate: {
-                    draftAttachment: {
-                        delete: mock(async () => { }),
-                        insert: mock(async () => { }),
-                        update: draftAttachmentUpdate,
-                    },
-                },
-                query: {
-                    draftAttachment: {
-                        where,
-                    },
-                },
-            };
-            const mutators = createMutators();
-            await mutators.draft.uploadAttachmentChunk(transaction, {
-                attachmentId: 'test-attachment-id-1',
-                chunk: 'dGVzdC1jaHVuaw==',
-                chunkIndex: 3,
-                id: 'test-draft-id-1',
-            });
-            expect(draftAttachmentUpdate).toHaveBeenCalledWith({
-                id: 'test-attachment-id-1',
-                uploadedChunks: 4,
-            });
-        });
-    });
 });

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

@@ -1,10 +1,12 @@
+import type { Transaction } from '@rocicorp/zero';
 import type * as v from 'valibot';
 import type { IMAPSourceLocation, LabelSpecialUse } from '../../../types';
 import { type AuthData, type HandlerMap } from '../../../types';
 import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
+import type { MarcoZeroSchema } from '../../../zero/schema';
 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<IMAPSourceLocation[]>;
+export declare const setSystemLabel: (tx: Transaction<MarcoZeroSchema>, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<IMAPSourceLocation[]>;
 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,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC9E,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,OACrB,GAAG,YACG,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,kBAAkB,EAAE,CA+D9B,CAAA;AAED,eAAO,MAAM,oBAAoB,cACpB,QAAQ,GAAG,SAAS,cACnB,sBAAsB,KACjC,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAiLxC,CAAA"}
+{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC9E,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAEhE,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,OACrB,WAAW,CAAC,eAAe,CAAC,YACtB,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,kBAAkB,EAAE,CAoE9B,CAAA;AAED,eAAO,MAAM,oBAAoB,cACpB,QAAQ,GAAG,SAAS,cACnB,sBAAsB,KACjC,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAoLxC,CAAA"}

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

@@ -4,49 +4,53 @@ export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
     if (!thread) {
         throw new Error(MutationError.ENTITY_NOT_FOUND);
     }
-    const { accountId } = thread;
     const targetLabel = await tx.query.accountLabel
-        .where('accountId', accountId)
+        .where('accountId', thread.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();
+    const threadLabels = await tx.query.threadLabel.where('threadId', threadId).run();
     const sourceLocations = [];
+    const labelsToDelete = [];
     let hasTarget = false;
-    for (const label of allThreadLabels) {
+    for (const label of threadLabels) {
         if (label.labelId === targetLabel.id) {
             hasTarget = true;
+            continue;
         }
-        else {
-            if (label.uid !== null &&
-                label.uid !== undefined &&
-                label.uidValidity !== null &&
-                label.uidValidity !== undefined) {
-                sourceLocations.push({
-                    labelId: label.labelId,
-                    threadMessageId: label.threadMessageId,
-                    uid: label.uid,
-                    uidValidity: label.uidValidity,
-                });
-            }
-            await tx.mutate.threadLabel.delete({
-                accountId,
+        labelsToDelete.push(label);
+        if (label.uid > 0 && label.uidValidity > 0) {
+            sourceLocations.push({
                 labelId: label.labelId,
                 threadMessageId: label.threadMessageId,
+                uid: label.uid,
+                uidValidity: label.uidValidity,
             });
         }
     }
+    for (const label of labelsToDelete) {
+        await tx.mutate.threadLabel.delete({
+            accountId: thread.accountId,
+            labelId: label.labelId,
+            threadMessageId: label.threadMessageId,
+        });
+    }
     if (!hasTarget) {
         const messages = await tx.query.threadMessage.where('threadId', threadId).run();
-        for (const message of messages) {
+        const baseTimestamp = Date.now();
+        for (let i = 0; i < messages.length; i++) {
+            const message = messages[i];
             await tx.mutate.threadLabel.insert({
-                accountId,
+                accountId: thread.accountId,
                 labelId: targetLabel.id,
+                lastSyncedAt: 0,
                 threadId,
                 threadMessageId: message.id,
+                uid: -(baseTimestamp + i),
+                uidValidity: targetLabel.uidValidity ?? 0,
             });
         }
     }
@@ -68,6 +72,8 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
             const messages = await tx.query.threadMessage.where('threadId', threadId).run();
+            const baseTimestamp = Date.now();
+            let insertIndex = 0;
             for (const message of messages) {
                 const existing = await tx.query.threadLabel
                     .where('threadMessageId', message.id)
@@ -78,9 +84,13 @@ export const createThreadMutators = (_authData, callbacks) => ({
                     await tx.mutate.threadLabel.insert({
                         accountId: thread.accountId,
                         labelId: label.id,
+                        lastSyncedAt: 0,
                         threadId,
                         threadMessageId: message.id,
+                        uid: -(baseTimestamp + insertIndex),
+                        uidValidity: label.uidValidity ?? 0,
                     });
+                    insertIndex++;
                 }
             }
         }
@@ -114,10 +124,7 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
             for (const existing of existingLabels) {
-                if (existing.uid !== null &&
-                    existing.uid !== undefined &&
-                    existing.uidValidity !== null &&
-                    existing.uidValidity !== undefined) {
+                if (existing.uid > 0 && existing.uidValidity > 0) {
                     allSourceLocations.push({
                         labelId: existing.labelId,
                         threadMessageId: existing.threadMessageId,

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

@@ -56,18 +56,18 @@ describe('threadMutators', () => {
                 threadIds: ['test-thread-id-1'],
             });
             expect(threadLabelInsert).toHaveBeenCalledTimes(2);
-            expect(threadLabelInsert).toHaveBeenCalledWith({
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
                 accountId: 'test-account-id-1',
                 labelId: 'test-label-id-1',
                 threadId: 'test-thread-id-1',
                 threadMessageId: 'test-message-id-1',
-            });
-            expect(threadLabelInsert).toHaveBeenCalledWith({
+            }));
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
                 accountId: 'test-account-id-1',
                 labelId: 'test-label-id-1',
                 threadId: 'test-thread-id-1',
                 threadMessageId: 'test-message-id-2',
-            });
+            }));
         });
     });
     describe('delete', () => {
@@ -257,12 +257,12 @@ describe('threadMutators', () => {
                 labelId: 'test-inbox-label-id',
                 threadMessageId: 'test-message-id-1',
             });
-            expect(threadLabelInsert).toHaveBeenCalledWith({
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
                 accountId: 'test-account-id-1',
                 labelId: 'test-archive-label-id',
                 threadId: 'test-thread-id-1',
                 threadMessageId: 'test-message-id-1',
-            });
+            }));
         });
     });
     describe('setFlagged', () => {
@@ -346,12 +346,12 @@ describe('threadMutators', () => {
                 labelId: 'test-archive-label-id',
                 threadMessageId: 'test-message-id-1',
             });
-            expect(threadLabelInsert).toHaveBeenCalledWith({
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
                 accountId: 'test-account-id-1',
                 labelId: 'test-inbox-label-id',
                 threadId: 'test-thread-id-1',
                 threadMessageId: 'test-message-id-1',
-            });
+            }));
         });
     });
     describe('setSeen', () => {
@@ -431,12 +431,12 @@ describe('threadMutators', () => {
                 sourceLocations: [],
                 threadIds: ['test-thread-id-1'],
             });
-            expect(threadLabelInsert).toHaveBeenCalledWith({
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
                 accountId: 'test-account-id-1',
                 labelId: 'test-spam-label-id',
                 threadId: 'test-thread-id-1',
                 threadMessageId: 'test-message-id-1',
-            });
+            }));
         });
     });
     describe('setTrash', () => {
@@ -489,12 +489,12 @@ describe('threadMutators', () => {
                 sourceLocations: [],
                 threadIds: ['test-thread-id-1'],
             });
-            expect(threadLabelInsert).toHaveBeenCalledWith({
+            expect(threadLabelInsert).toHaveBeenCalledWith(expect.objectContaining({
                 accountId: 'test-account-id-1',
                 labelId: 'test-trash-label-id',
                 threadId: 'test-thread-id-1',
                 threadMessageId: 'test-message-id-1',
-            });
+            }));
         });
     });
 });

package/dist/zero/queries/getAccounts.d.ts

@@ -237,6 +237,13 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
                 } & {
                     serverName: string;
                 };
+                readonly uidValidity: {
+                    type: "number";
+                    optional: false;
+                    customType: number;
+                } & {
+                    serverName: string;
+                };
             };
             primaryKey: readonly [string, ...string[]];
         } & {
@@ -419,10 +426,10 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
                 } & {
                     serverName: string;
                 };
-                readonly totalChunks: {
-                    type: "number";
+                readonly status: {
+                    type: "string";
                     optional: false;
-                    customType: number;
+                    customType: "PENDING" | "COMPLETE" | "FAILED";
                 } & {
                     serverName: string;
                 };
@@ -433,13 +440,6 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
                 } & {
                     serverName: string;
                 };
-                readonly uploadedChunks: {
-                    type: "number";
-                    optional: false;
-                    customType: number;
-                } & {
-                    serverName: string;
-                };
             };
             primaryKey: readonly [string, ...string[]];
         } & {
@@ -511,6 +511,13 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
                 } & {
                     serverName: string;
                 };
+                readonly lastSyncedAt: {
+                    type: "number";
+                    optional: false;
+                    customType: number;
+                } & {
+                    serverName: string;
+                };
                 readonly threadId: {
                     type: "string";
                     optional: false;
@@ -525,19 +532,15 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
                 } & {
                     serverName: string;
                 };
-                readonly uid: Omit<{
+                readonly uid: {
                     type: "number";
                     optional: false;
                     customType: number;
-                }, "optional"> & {
-                    optional: true;
                 };
-                readonly uidValidity: Omit<{
+                readonly uidValidity: {
                     type: "number";
                     optional: false;
                     customType: number;
-                }, "optional"> & {
-                    optional: true;
                 } & {
                     serverName: string;
                 };
@@ -760,7 +763,7 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
             }];
             labels: [{
                 readonly sourceField: string[];
-                readonly destField: ("id" | "accountId" | "path" | "specialUse")[];
+                readonly destField: ("id" | "accountId" | "path" | "specialUse" | "uidValidity")[];
                 readonly destSchema: "accountLabel";
                 readonly cardinality: "many";
             }];
@@ -800,7 +803,7 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
             }];
             threads: [{
                 readonly sourceField: string[];
-                readonly destField: ("accountId" | "labelId" | "threadId" | "threadMessageId" | "uidValidity" | "uid")[];
+                readonly destField: ("accountId" | "uidValidity" | "labelId" | "lastSyncedAt" | "threadId" | "threadMessageId" | "uid")[];
                 readonly destSchema: "threadLabel";
                 readonly cardinality: "many";
             }, {
@@ -819,7 +822,7 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
             }];
             attachments: [{
                 readonly sourceField: string[];
-                readonly destField: ("id" | "draftId" | "failed" | "fileName" | "mimeType" | "totalChunks" | "totalSize" | "uploadedChunks")[];
+                readonly destField: ("status" | "id" | "draftId" | "failed" | "fileName" | "mimeType" | "totalSize")[];
                 readonly destSchema: "draftAttachment";
                 readonly cardinality: "many";
             }];
@@ -861,12 +864,12 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
             }];
             labels: [{
                 readonly sourceField: string[];
-                readonly destField: ("accountId" | "labelId" | "threadId" | "threadMessageId" | "uidValidity" | "uid")[];
+                readonly destField: ("accountId" | "uidValidity" | "labelId" | "lastSyncedAt" | "threadId" | "threadMessageId" | "uid")[];
                 readonly destSchema: "threadLabel";
                 readonly cardinality: "many";
             }, {
                 readonly sourceField: string[];
-                readonly destField: ("id" | "accountId" | "path" | "specialUse")[];
+                readonly destField: ("id" | "accountId" | "path" | "specialUse" | "uidValidity")[];
                 readonly destSchema: "accountLabel";
                 readonly cardinality: "many";
             }];
@@ -886,7 +889,7 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
         readonly threadLabel: {
             label: [{
                 readonly sourceField: string[];
-                readonly destField: ("id" | "accountId" | "path" | "specialUse")[];
+                readonly destField: ("id" | "accountId" | "path" | "specialUse" | "uidValidity")[];
                 readonly destSchema: "accountLabel";
                 readonly cardinality: "one";
             }];
@@ -912,12 +915,12 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
             }];
             labels: [{
                 readonly sourceField: string[];
-                readonly destField: ("accountId" | "labelId" | "threadId" | "threadMessageId" | "uidValidity" | "uid")[];
+                readonly destField: ("accountId" | "uidValidity" | "labelId" | "lastSyncedAt" | "threadId" | "threadMessageId" | "uid")[];
                 readonly destSchema: "threadLabel";
                 readonly cardinality: "many";
             }, {
                 readonly sourceField: string[];
-                readonly destField: ("id" | "accountId" | "path" | "specialUse")[];
+                readonly destField: ("id" | "accountId" | "path" | "specialUse" | "uidValidity")[];
                 readonly destSchema: "accountLabel";
                 readonly cardinality: "many";
             }];
@@ -984,6 +987,7 @@ export declare const getAccounts: import("@rocicorp/zero").SyncedQuery<"getAccou
         readonly id: string;
         readonly path: string;
         readonly specialUse: "ARCHIVE" | "INBOX" | "SENT" | "SPAM" | "TRASH" | null;
+        readonly uidValidity: number;
     }[];
 }>>;
 //# sourceMappingURL=getAccounts.d.ts.map