@marcoappio/marco-config 2.0.289 → 2.0.291

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

@@ -33,9 +33,9 @@ export declare const sync: {
                     readonly value: import("valibot").ObjectSchema<{
                         readonly aliases: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                             readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            readonly hidden: import("valibot").BooleanSchema<undefined>;
                             readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-                            readonly isHidden: import("valibot").BooleanSchema<undefined>;
-                            readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                            readonly primary: import("valibot").BooleanSchema<undefined>;
                         }, undefined>, undefined>;
                         readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -146,9 +146,11 @@ export declare const sync: {
                             readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                         }, undefined>;
                         readonly emailAccountId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                        readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                         readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                         readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>, undefined>;
-                        readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SENDING", undefined>, import("valibot").LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
+                        readonly scheduledFor: import("valibot").NullableSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+                        readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SEND_REQUESTED", undefined>, import("valibot").LiteralSchema<"SEND_CONFIRMATION_PENDING", undefined>, import("valibot").LiteralSchema<"SEND_CONFIRMED", undefined>], undefined>;
                         readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"NEW", undefined>, import("valibot").LiteralSchema<"REPLY", undefined>, import("valibot").LiteralSchema<"FORWARD", undefined>], undefined>;
                         readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                     }, undefined>;
@@ -297,14 +299,14 @@ export declare const sync: {
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"add", undefined>;
+                readonly name: import("valibot").LiteralSchema<"createAccount", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                     readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly hidden: import("valibot").BooleanSchema<undefined>;
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-                    readonly isHidden: import("valibot").BooleanSchema<undefined>;
-                    readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                    readonly primary: import("valibot").BooleanSchema<undefined>;
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
@@ -315,7 +317,7 @@ export declare const sync: {
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+                readonly name: import("valibot").LiteralSchema<"deleteAccount", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -326,6 +328,7 @@ export declare const sync: {
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                    readonly hidden: import("valibot").BooleanSchema<undefined>;
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
@@ -337,21 +340,6 @@ export declare const sync: {
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
                 readonly name: import("valibot").LiteralSchema<"setAliasPrimary", undefined>;
-            }, undefined> | import("valibot").ObjectSchema<{
-                readonly args: import("valibot").ObjectSchema<{
-                    readonly connectionConfig: import("valibot").ObjectSchema<{
-                        readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                        readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                        readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-                        readonly smtpHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                        readonly smtpPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                        readonly smtpPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-                    }, undefined>;
-                    readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-                }, undefined>;
-                readonly clientID: import("valibot").StringSchema<undefined>;
-                readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"setConnectionConfig", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly connectionConfig: import("valibot").ObjectSchema<{
@@ -438,6 +426,29 @@ export declare const sync: {
         draft: import("../../../..").EndpointConfig<"/v1/pv/sync/push/draft", import("valibot").ObjectSchema<{
             readonly clientGroupID: import("valibot").StringSchema<undefined>;
             readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"cancelDraftSend", undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly attachment: import("valibot").ObjectSchema<{
+                        readonly failed: import("valibot").BooleanSchema<undefined>;
+                        readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                        readonly mimeType: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly totalChunks: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                        readonly totalSize: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                        readonly uploadedChunks: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                    }, undefined>;
+                    readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"createAttachment", undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                         readonly failed: import("valibot").BooleanSchema<undefined>;
@@ -456,46 +467,39 @@ export declare const sync: {
                         readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                     }, undefined>;
                     readonly emailAccountId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                    readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                     readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>, undefined>;
-                    readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SENDING", undefined>, import("valibot").LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
+                    readonly scheduledFor: import("valibot").NullableSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+                    readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SEND_REQUESTED", undefined>, import("valibot").LiteralSchema<"SEND_CONFIRMATION_PENDING", undefined>, import("valibot").LiteralSchema<"SEND_CONFIRMED", undefined>], undefined>;
                     readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"NEW", undefined>, import("valibot").LiteralSchema<"REPLY", undefined>, import("valibot").LiteralSchema<"FORWARD", undefined>], undefined>;
                     readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"create", undefined>;
+                readonly name: import("valibot").LiteralSchema<"createDraft", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
-                    readonly attachment: import("valibot").ObjectSchema<{
-                        readonly failed: import("valibot").BooleanSchema<undefined>;
-                        readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                        readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-                        readonly mimeType: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                        readonly totalChunks: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                        readonly totalSize: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                        readonly uploadedChunks: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                    }, undefined>;
+                    readonly attachmentId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"createAttachment", undefined>;
+                readonly name: import("valibot").LiteralSchema<"deleteAttachment", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+                readonly name: import("valibot").LiteralSchema<"deleteDraft", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
-                    readonly attachmentId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"deleteAttachment", undefined>;
+                readonly name: import("valibot").LiteralSchema<"sendDraft", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -576,12 +580,12 @@ export declare const sync: {
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-                    readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SENDING", undefined>, import("valibot").LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
+                    readonly scheduledFor: import("valibot").NullableSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
                     readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"setStatus", undefined>;
+                readonly name: import("valibot").LiteralSchema<"setScheduledFor", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly attachmentId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;

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

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

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

@@ -32,9 +32,9 @@ export declare const syncPullAccount: import("../../../../..").EndpointConfig<"/
             readonly value: v.ObjectSchema<{
                 readonly aliases: v.ArraySchema<v.ObjectSchema<{
                     readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly hidden: v.BooleanSchema<undefined>;
                     readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-                    readonly isHidden: v.BooleanSchema<undefined>;
-                    readonly isPrimary: v.BooleanSchema<undefined>;
+                    readonly primary: v.BooleanSchema<undefined>;
                 }, undefined>, undefined>;
                 readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;

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

@@ -47,9 +47,11 @@ export declare const syncPullDraft: import("../../../../..").EndpointConfig<"/v1
                     readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                 }, undefined>;
                 readonly emailAccountId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                readonly error: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                 readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>, undefined>;
-                readonly status: v.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SENDING", undefined>, v.LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
+                readonly scheduledFor: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+                readonly status: v.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SEND_REQUESTED", undefined>, v.LiteralSchema<"SEND_CONFIRMATION_PENDING", undefined>, v.LiteralSchema<"SEND_CONFIRMED", undefined>], undefined>;
                 readonly type: v.UnionSchema<[v.LiteralSchema<"NEW", undefined>, v.LiteralSchema<"REPLY", undefined>, v.LiteralSchema<"FORWARD", undefined>], undefined>;
                 readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
             }, undefined>;

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

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

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

@@ -32,9 +32,9 @@ export declare const pull: {
                 readonly value: import("valibot").ObjectSchema<{
                     readonly aliases: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                         readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly hidden: import("valibot").BooleanSchema<undefined>;
                         readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-                        readonly isHidden: import("valibot").BooleanSchema<undefined>;
-                        readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                        readonly primary: import("valibot").BooleanSchema<undefined>;
                     }, undefined>, undefined>;
                     readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -145,9 +145,11 @@ export declare const pull: {
                         readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                     }, undefined>;
                     readonly emailAccountId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                    readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                     readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>, undefined>;
-                    readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SENDING", undefined>, import("valibot").LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
+                    readonly scheduledFor: import("valibot").NullableSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+                    readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SEND_REQUESTED", undefined>, import("valibot").LiteralSchema<"SEND_CONFIRMATION_PENDING", undefined>, import("valibot").LiteralSchema<"SEND_CONFIRMED", undefined>], undefined>;
                     readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"NEW", undefined>, import("valibot").LiteralSchema<"REPLY", undefined>, import("valibot").LiteralSchema<"FORWARD", undefined>], undefined>;
                     readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                 }, undefined>;

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

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

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

@@ -9,14 +9,14 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"add", undefined>;
+        readonly name: v.LiteralSchema<"createAccount", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
             readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly hidden: v.BooleanSchema<undefined>;
             readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-            readonly isHidden: v.BooleanSchema<undefined>;
-            readonly isPrimary: v.BooleanSchema<undefined>;
+            readonly primary: v.BooleanSchema<undefined>;
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
@@ -27,7 +27,7 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"delete", undefined>;
+        readonly name: v.LiteralSchema<"deleteAccount", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -38,6 +38,7 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            readonly hidden: v.BooleanSchema<undefined>;
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
@@ -49,21 +50,6 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
         readonly name: v.LiteralSchema<"setAliasPrimary", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.ObjectSchema<{
-            readonly connectionConfig: v.ObjectSchema<{
-                readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-                readonly smtpHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly smtpPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly smtpPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-            }, undefined>;
-            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-        }, undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setConnectionConfig", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly connectionConfig: v.ObjectSchema<{

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

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

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

@@ -6,11 +6,11 @@ export const syncPushAccount = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
         mutations: v.array(v.union(Object.values({
-            add: v.object({
-                args: account.mutators.add.delta,
+            createAccount: v.object({
+                args: account.mutators.createAccount.delta,
                 clientID: v.string(),
                 id: v.number(),
-                name: v.literal('add'),
+                name: v.literal('createAccount'),
             }),
             createAlias: v.object({
                 args: account.mutators.createAlias.delta,
@@ -18,11 +18,11 @@ export const syncPushAccount = createEndpoint({
                 id: v.number(),
                 name: v.literal('createAlias'),
             }),
-            delete: v.object({
-                args: account.mutators.delete.delta,
+            deleteAccount: v.object({
+                args: account.mutators.deleteAccount.delta,
                 clientID: v.string(),
                 id: v.number(),
-                name: v.literal('delete'),
+                name: v.literal('deleteAccount'),
             }),
             deleteAlias: v.object({
                 args: account.mutators.deleteAlias.delta,
@@ -42,12 +42,6 @@ export const syncPushAccount = createEndpoint({
                 id: v.number(),
                 name: v.literal('setAliasPrimary'),
             }),
-            setConnectionConfig: v.object({
-                args: account.mutators.setConnectionConfig.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setConnectionConfig'),
-            }),
             setConnectionConfigImapRaw: v.object({
                 args: account.mutators.setConnectionConfigImapRaw.delta,
                 clientID: v.string(),

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

@@ -2,6 +2,29 @@ import * as v from 'valibot';
 export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1/pv/sync/push/draft", v.ObjectSchema<{
     readonly clientGroupID: v.StringSchema<undefined>;
     readonly mutations: v.ArraySchema<v.UnionSchema<(v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"cancelDraftSend", undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly attachment: v.ObjectSchema<{
+                readonly failed: v.BooleanSchema<undefined>;
+                readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly totalChunks: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly totalSize: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly uploadedChunks: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"createAttachment", undefined>;
+    }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly attachments: v.ArraySchema<v.ObjectSchema<{
                 readonly failed: v.BooleanSchema<undefined>;
@@ -20,46 +43,39 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
                 readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
             }, undefined>;
             readonly emailAccountId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            readonly error: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
             readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>, undefined>;
-            readonly status: v.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SENDING", undefined>, v.LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
+            readonly scheduledFor: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+            readonly status: v.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SEND_REQUESTED", undefined>, v.LiteralSchema<"SEND_CONFIRMATION_PENDING", undefined>, v.LiteralSchema<"SEND_CONFIRMED", undefined>], undefined>;
             readonly type: v.UnionSchema<[v.LiteralSchema<"NEW", undefined>, v.LiteralSchema<"REPLY", undefined>, v.LiteralSchema<"FORWARD", undefined>], undefined>;
             readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"create", undefined>;
+        readonly name: v.LiteralSchema<"createDraft", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
-            readonly attachment: v.ObjectSchema<{
-                readonly failed: v.BooleanSchema<undefined>;
-                readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-                readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly totalChunks: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                readonly totalSize: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                readonly uploadedChunks: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            }, undefined>;
+            readonly attachmentId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
             readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"createAttachment", undefined>;
+        readonly name: v.LiteralSchema<"deleteAttachment", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"delete", undefined>;
+        readonly name: v.LiteralSchema<"deleteDraft", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
-            readonly attachmentId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
             readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"deleteAttachment", undefined>;
+        readonly name: v.LiteralSchema<"sendDraft", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -140,12 +156,12 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
-            readonly status: v.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SENDING", undefined>, v.LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
+            readonly scheduledFor: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
             readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setStatus", undefined>;
+        readonly name: v.LiteralSchema<"setScheduledFor", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly attachmentId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;

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

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

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

@@ -6,11 +6,11 @@ export const syncPushDraft = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
         mutations: v.array(v.union(Object.values({
-            create: v.object({
-                args: draft.mutators.create.delta,
+            cancelDraftSend: v.object({
+                args: draft.mutators.cancelDraftSend.delta,
                 clientID: v.string(),
                 id: v.number(),
-                name: v.literal('create'),
+                name: v.literal('cancelDraftSend'),
             }),
             createAttachment: v.object({
                 args: draft.mutators.createAttachment.delta,
@@ -18,11 +18,11 @@ export const syncPushDraft = createEndpoint({
                 id: v.number(),
                 name: v.literal('createAttachment'),
             }),
-            delete: v.object({
-                args: draft.mutators.delete.delta,
+            createDraft: v.object({
+                args: draft.mutators.createDraft.delta,
                 clientID: v.string(),
                 id: v.number(),
-                name: v.literal('delete'),
+                name: v.literal('createDraft'),
             }),
             deleteAttachment: v.object({
                 args: draft.mutators.deleteAttachment.delta,
@@ -30,6 +30,18 @@ export const syncPushDraft = createEndpoint({
                 id: v.number(),
                 name: v.literal('deleteAttachment'),
             }),
+            deleteDraft: v.object({
+                args: draft.mutators.deleteDraft.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('deleteDraft'),
+            }),
+            sendDraft: v.object({
+                args: draft.mutators.sendDraft.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('sendDraft'),
+            }),
             setContent: v.object({
                 args: draft.mutators.setContent.delta,
                 clientID: v.string(),
@@ -48,11 +60,11 @@ export const syncPushDraft = createEndpoint({
                 id: v.number(),
                 name: v.literal('setEnvelope'),
             }),
-            setStatus: v.object({
-                args: draft.mutators.setStatus.delta,
+            setScheduledFor: v.object({
+                args: draft.mutators.setScheduledFor.delta,
                 clientID: v.string(),
                 id: v.number(),
-                name: v.literal('setStatus'),
+                name: v.literal('setScheduledFor'),
             }),
             uploadAttachmentChunk: v.object({
                 args: draft.mutators.uploadAttachmentChunk.delta,