@marcoappio/marco-config 2.0.158 → 2.0.160

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

@@ -81,6 +81,44 @@ export declare const privateGroup: {
                 }, undefined>;
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
             }, undefined>], undefined>>;
+            draft: import("../../..").EndpointConfig<"/v1/pv/sync/pull/draft", import("valibot").ObjectSchema<{
+                readonly clientGroupID: import("valibot").StringSchema<undefined>;
+                readonly cookie: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                readonly status: import("valibot").LiteralSchema<400, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly cookie: import("valibot").NumberSchema<undefined>;
+                    readonly lastMutationIDChanges: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>, undefined>;
+                    readonly patch: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                        readonly op: import("valibot").LiteralSchema<"clear", undefined>;
+                    }, undefined>, import("valibot").ObjectSchema<{
+                        readonly key: import("valibot").StringSchema<undefined>;
+                        readonly op: import("valibot").LiteralSchema<"del", undefined>;
+                    }, undefined>, import("valibot").ObjectSchema<{
+                        readonly key: import("valibot").StringSchema<undefined>;
+                        readonly op: import("valibot").LiteralSchema<"put", undefined>;
+                        readonly value: import("valibot").ObjectSchema<{
+                            readonly body: import("valibot").ObjectSchema<{
+                                readonly bcc: 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>;
+                                readonly cc: 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>;
+                                readonly content: import("valibot").UnknownSchema;
+                                readonly replyTo: 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>;
+                                readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                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").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        }, undefined>;
+                    }, undefined>], undefined>, undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>>;
             thread: import("../../..").EndpointConfig<"/v1/pv/sync/pull/thread", import("valibot").ObjectSchema<{
                 readonly clientGroupID: import("valibot").StringSchema<undefined>;
                 readonly cookie: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
@@ -268,6 +306,108 @@ export declare const privateGroup: {
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
             }, undefined>], undefined>>;
+            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").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly args: import("valibot").ObjectSchema<{
+                        readonly body: Omit<import("valibot").ObjectSchema<{
+                            readonly bcc: 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>;
+                            readonly cc: 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>;
+                            readonly content: import("valibot").UnknownSchema;
+                            readonly replyTo: 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>;
+                            readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            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>, "entries" | "~standard" | "~run" | "~types"> & {
+                            readonly entries: {
+                                readonly bcc: import("valibot").OptionalSchema<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 cc: import("valibot").OptionalSchema<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 content: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                                readonly replyTo: import("valibot").OptionalSchema<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 subject: import("valibot").OptionalSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                                readonly to: import("valibot").OptionalSchema<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 '~standard': import("valibot").StandardSchemaProps<{
+                                bcc?: string[] | undefined;
+                                cc?: string[] | undefined;
+                                replyTo?: string[] | undefined;
+                                to?: string[] | undefined;
+                                content?: unknown;
+                                subject?: string | undefined;
+                            }, {
+                                bcc?: string[] | undefined;
+                                cc?: string[] | undefined;
+                                replyTo?: string[] | undefined;
+                                to?: string[] | undefined;
+                                content?: unknown;
+                                subject?: string | undefined;
+                            }>;
+                            readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+                                bcc?: string[] | undefined;
+                                cc?: string[] | undefined;
+                                replyTo?: string[] | undefined;
+                                to?: string[] | undefined;
+                                content?: unknown;
+                                subject?: string | undefined;
+                            }, import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue>;
+                            readonly '~types'?: {
+                                readonly input: {
+                                    bcc?: string[] | undefined;
+                                    cc?: string[] | undefined;
+                                    replyTo?: string[] | undefined;
+                                    to?: string[] | undefined;
+                                    content?: unknown;
+                                    subject?: string | undefined;
+                                };
+                                readonly output: {
+                                    bcc?: string[] | undefined;
+                                    cc?: string[] | undefined;
+                                    replyTo?: string[] | undefined;
+                                    to?: string[] | undefined;
+                                    content?: unknown;
+                                    subject?: string | undefined;
+                                };
+                                readonly issue: import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue;
+                            } | undefined;
+                        };
+                        readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"update", undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly args: import("valibot").ObjectSchema<{
+                        readonly body: import("valibot").ObjectSchema<{
+                            readonly bcc: 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>;
+                            readonly cc: 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>;
+                            readonly content: import("valibot").UnknownSchema;
+                            readonly replyTo: 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>;
+                            readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            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").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"create", undefined>;
+                }, undefined>], undefined>, undefined>;
+            }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                readonly status: import("valibot").LiteralSchema<400, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>>;
             thread: import("../../..").EndpointConfig<"/v1/pv/sync/push/thread", import("valibot").ObjectSchema<{
                 readonly clientGroupID: import("valibot").StringSchema<undefined>;
                 readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{

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

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

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

@@ -80,6 +80,44 @@ export declare const sync: {
             }, undefined>;
             readonly status: import("valibot").LiteralSchema<200, undefined>;
         }, undefined>], undefined>>;
+        draft: import("../../../..").EndpointConfig<"/v1/pv/sync/pull/draft", import("valibot").ObjectSchema<{
+            readonly clientGroupID: import("valibot").StringSchema<undefined>;
+            readonly cookie: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+            readonly status: import("valibot").LiteralSchema<400, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+            readonly status: import("valibot").LiteralSchema<401, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly cookie: import("valibot").NumberSchema<undefined>;
+                readonly lastMutationIDChanges: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>, undefined>;
+                readonly patch: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                    readonly op: import("valibot").LiteralSchema<"clear", undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly key: import("valibot").StringSchema<undefined>;
+                    readonly op: import("valibot").LiteralSchema<"del", undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly key: import("valibot").StringSchema<undefined>;
+                    readonly op: import("valibot").LiteralSchema<"put", undefined>;
+                    readonly value: import("valibot").ObjectSchema<{
+                        readonly body: import("valibot").ObjectSchema<{
+                            readonly bcc: 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>;
+                            readonly cc: 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>;
+                            readonly content: import("valibot").UnknownSchema;
+                            readonly replyTo: 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>;
+                            readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            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").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    }, undefined>;
+                }, undefined>], undefined>, undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<200, undefined>;
+        }, undefined>], undefined>>;
         thread: import("../../../..").EndpointConfig<"/v1/pv/sync/pull/thread", import("valibot").ObjectSchema<{
             readonly clientGroupID: import("valibot").StringSchema<undefined>;
             readonly cookie: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
@@ -267,6 +305,108 @@ export declare const sync: {
         }, undefined>, import("valibot").ObjectSchema<{
             readonly status: import("valibot").LiteralSchema<200, undefined>;
         }, undefined>], undefined>>;
+        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").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly body: Omit<import("valibot").ObjectSchema<{
+                        readonly bcc: 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>;
+                        readonly cc: 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>;
+                        readonly content: import("valibot").UnknownSchema;
+                        readonly replyTo: 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>;
+                        readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        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>, "entries" | "~standard" | "~run" | "~types"> & {
+                        readonly entries: {
+                            readonly bcc: import("valibot").OptionalSchema<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 cc: import("valibot").OptionalSchema<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 content: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                            readonly replyTo: import("valibot").OptionalSchema<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 subject: import("valibot").OptionalSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                            readonly to: import("valibot").OptionalSchema<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 '~standard': import("valibot").StandardSchemaProps<{
+                            bcc?: string[] | undefined;
+                            cc?: string[] | undefined;
+                            replyTo?: string[] | undefined;
+                            to?: string[] | undefined;
+                            content?: unknown;
+                            subject?: string | undefined;
+                        }, {
+                            bcc?: string[] | undefined;
+                            cc?: string[] | undefined;
+                            replyTo?: string[] | undefined;
+                            to?: string[] | undefined;
+                            content?: unknown;
+                            subject?: string | undefined;
+                        }>;
+                        readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+                            bcc?: string[] | undefined;
+                            cc?: string[] | undefined;
+                            replyTo?: string[] | undefined;
+                            to?: string[] | undefined;
+                            content?: unknown;
+                            subject?: string | undefined;
+                        }, import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue>;
+                        readonly '~types'?: {
+                            readonly input: {
+                                bcc?: string[] | undefined;
+                                cc?: string[] | undefined;
+                                replyTo?: string[] | undefined;
+                                to?: string[] | undefined;
+                                content?: unknown;
+                                subject?: string | undefined;
+                            };
+                            readonly output: {
+                                bcc?: string[] | undefined;
+                                cc?: string[] | undefined;
+                                replyTo?: string[] | undefined;
+                                to?: string[] | undefined;
+                                content?: unknown;
+                                subject?: string | undefined;
+                            };
+                            readonly issue: import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue;
+                        } | undefined;
+                    };
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"update", undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly body: import("valibot").ObjectSchema<{
+                        readonly bcc: 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>;
+                        readonly cc: 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>;
+                        readonly content: import("valibot").UnknownSchema;
+                        readonly replyTo: 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>;
+                        readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        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").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"create", undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+            readonly status: import("valibot").LiteralSchema<400, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+            readonly status: import("valibot").LiteralSchema<401, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly status: import("valibot").LiteralSchema<200, undefined>;
+        }, undefined>], undefined>>;
         thread: import("../../../..").EndpointConfig<"/v1/pv/sync/push/thread", import("valibot").ObjectSchema<{
             readonly clientGroupID: import("valibot").StringSchema<undefined>;
             readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{

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

@@ -0,0 +1,40 @@
+import * as v from 'valibot';
+export declare const syncPullDraft: import("../../../../..").EndpointConfig<"/v1/pv/sync/pull/draft", v.ObjectSchema<{
+    readonly clientGroupID: v.StringSchema<undefined>;
+    readonly cookie: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
+    readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly cookie: v.NumberSchema<undefined>;
+        readonly lastMutationIDChanges: v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>;
+        readonly patch: v.ArraySchema<v.UnionSchema<[v.ObjectSchema<{
+            readonly op: v.LiteralSchema<"clear", undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly key: v.StringSchema<undefined>;
+            readonly op: v.LiteralSchema<"del", undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly key: v.StringSchema<undefined>;
+            readonly op: v.LiteralSchema<"put", undefined>;
+            readonly value: v.ObjectSchema<{
+                readonly body: v.ObjectSchema<{
+                    readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly content: v.UnknownSchema;
+                    readonly replyTo: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly subject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    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.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=draft.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAwBxB,CAAA"}

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

@@ -0,0 +1,28 @@
+import * as v from 'valibot';
+import { draft } from '../../../../../clients/draft';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { errorManifest } from '../../../../../sdk/validation/errors';
+export const syncPullDraft = createEndpoint({
+    body: v.object({
+        clientGroupID: v.string(),
+        cookie: v.nullable(v.number()),
+    }),
+    method: 'POST',
+    path: draft.pullURL,
+    response: v.union([
+        errorManifest.validationFailedErrorSchema,
+        errorManifest.authenticationFailedErrorSchema,
+        v.object({
+            data: v.object({
+                cookie: v.number(),
+                lastMutationIDChanges: v.record(v.string(), v.number()),
+                patch: v.array(v.union([
+                    v.object({ op: v.literal('clear') }),
+                    v.object({ key: v.string(), op: v.literal('del') }),
+                    v.object({ key: v.string(), op: v.literal('put'), value: draft.model }),
+                ])),
+            }),
+            status: v.literal(200),
+        }),
+    ]),
+});

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

@@ -79,6 +79,44 @@ export declare const pull: {
         }, undefined>;
         readonly status: import("valibot").LiteralSchema<200, undefined>;
     }, undefined>], undefined>>;
+    draft: import("../../../../..").EndpointConfig<"/v1/pv/sync/pull/draft", import("valibot").ObjectSchema<{
+        readonly clientGroupID: import("valibot").StringSchema<undefined>;
+        readonly cookie: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly status: import("valibot").LiteralSchema<400, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly cookie: import("valibot").NumberSchema<undefined>;
+            readonly lastMutationIDChanges: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>, undefined>;
+            readonly patch: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly op: import("valibot").LiteralSchema<"clear", undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly key: import("valibot").StringSchema<undefined>;
+                readonly op: import("valibot").LiteralSchema<"del", undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly key: import("valibot").StringSchema<undefined>;
+                readonly op: import("valibot").LiteralSchema<"put", undefined>;
+                readonly value: import("valibot").ObjectSchema<{
+                    readonly body: import("valibot").ObjectSchema<{
+                        readonly bcc: 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>;
+                        readonly cc: 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>;
+                        readonly content: import("valibot").UnknownSchema;
+                        readonly replyTo: 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>;
+                        readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        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").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<200, undefined>;
+    }, undefined>], undefined>>;
     thread: import("../../../../..").EndpointConfig<"/v1/pv/sync/pull/thread", import("valibot").ObjectSchema<{
         readonly clientGroupID: import("valibot").StringSchema<undefined>;
         readonly cookie: import("valibot").NullableSchema<import("valibot").ObjectSchema<{

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":"AAKA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/pull/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4C,CAAA"}

package/dist/sdk/endpoints/private/sync/pull/index.js

@@ -1,5 +1,6 @@
 import { syncPullAccount as account } from './account';
 import { syncPullContact as contact } from './contact';
+import { syncPullDraft as draft } from './draft';
 import { syncPullThread as thread } from './thread';
 import { syncPullUser as user } from './user';
-export const pull = { account, contact, thread, user };
+export const pull = { account, contact, draft, thread, user };

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

@@ -0,0 +1,104 @@
+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.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"delete", undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly body: Omit<v.ObjectSchema<{
+                readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly content: v.UnknownSchema;
+                readonly replyTo: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly subject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            }, undefined>, "entries" | "~standard" | "~run" | "~types"> & {
+                readonly entries: {
+                    readonly bcc: v.OptionalSchema<v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                    readonly cc: v.OptionalSchema<v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                    readonly content: v.OptionalSchema<v.UnknownSchema, undefined>;
+                    readonly replyTo: v.OptionalSchema<v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                    readonly subject: v.OptionalSchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly to: v.OptionalSchema<v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                };
+                readonly '~standard': v.StandardSchemaProps<{
+                    bcc?: string[] | undefined;
+                    cc?: string[] | undefined;
+                    replyTo?: string[] | undefined;
+                    to?: string[] | undefined;
+                    content?: unknown;
+                    subject?: string | undefined;
+                }, {
+                    bcc?: string[] | undefined;
+                    cc?: string[] | undefined;
+                    replyTo?: string[] | undefined;
+                    to?: string[] | undefined;
+                    content?: unknown;
+                    subject?: string | undefined;
+                }>;
+                readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                    bcc?: string[] | undefined;
+                    cc?: string[] | undefined;
+                    replyTo?: string[] | undefined;
+                    to?: string[] | undefined;
+                    content?: unknown;
+                    subject?: string | undefined;
+                }, v.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ObjectIssue | v.NonOptionalIssue | v.ArrayIssue>;
+                readonly '~types'?: {
+                    readonly input: {
+                        bcc?: string[] | undefined;
+                        cc?: string[] | undefined;
+                        replyTo?: string[] | undefined;
+                        to?: string[] | undefined;
+                        content?: unknown;
+                        subject?: string | undefined;
+                    };
+                    readonly output: {
+                        bcc?: string[] | undefined;
+                        cc?: string[] | undefined;
+                        replyTo?: string[] | undefined;
+                        to?: string[] | undefined;
+                        content?: unknown;
+                        subject?: string | undefined;
+                    };
+                    readonly issue: v.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ObjectIssue | v.NonOptionalIssue | v.ArrayIssue;
+                } | undefined;
+            };
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"update", undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly body: v.ObjectSchema<{
+                readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly content: v.UnknownSchema;
+                readonly replyTo: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly subject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                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.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"create", undefined>;
+    }, undefined>], undefined>, undefined>;
+}, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
+    readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=draft.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA+BxB,CAAA"}