@marcoappio/marco-config 2.0.413 → 2.0.415

package/dist/clients/account.d.ts

@@ -0,0 +1,144 @@
+import * as v from 'valibot';
+export declare const account: {
+    model: v.ObjectSchema<{
+        readonly aliases: v.ObjectSchema<{
+            readonly nonPrimary: v.ArraySchema<v.ObjectSchema<{
+                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>, undefined>;
+            readonly primary: v.ObjectSchema<{
+                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly imapConnectionStatus: v.PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "CONNECTION_FAILED_AUTHENTICATION_ERROR", "CONNECTION_FAILED_CONNECTION_ERROR", "CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", "CONNECTION_FAILED_QUOTA_ERROR", "CONNECTION_FAILED_UNKNOWN_ERROR"], undefined>;
+        readonly labels: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly path: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly specialUse: v.NullableSchema<v.PicklistSchema<readonly ["ARCHIVE", "INBOX", "SENT", "SPAM", "TRASH"], undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly mailCounts: v.ObjectSchema<{
+            readonly processed: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly total: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>;
+        readonly settings: v.ObjectSchema<{
+            readonly color: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    mutators: {
+        createAccount: {
+            delta: v.ObjectSchema<{
+                readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly color: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        createAlias: {
+            delta: v.ObjectSchema<{
+                readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly alias: v.ObjectSchema<{
+                    readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+            }, undefined>;
+        };
+        deleteAccount: {
+            delta: v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        deleteAlias: {
+            delta: v.ObjectSchema<{
+                readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        setAliasName: {
+            delta: v.ObjectSchema<{
+                readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        setAliasPrimary: {
+            delta: v.ObjectSchema<{
+                readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        setConnectionConfigImapRaw: {
+            delta: v.ObjectSchema<{
+                readonly connectionConfig: v.ObjectSchema<{
+                    readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
+                    readonly imapSocketType: v.UnionSchema<[v.LiteralSchema<"STARTTLS", undefined>, v.LiteralSchema<"SSL", undefined>], undefined>;
+                    readonly imapUser: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly smtpHost: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly smtpPassword: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly smtpPort: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
+                    readonly smtpSocketType: v.UnionSchema<[v.LiteralSchema<"STARTTLS", undefined>, v.LiteralSchema<"SSL", undefined>], undefined>;
+                    readonly smtpUser: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        setConnectionConfigOauth: {
+            delta: v.ObjectSchema<{
+                readonly connectionConfig: v.ObjectSchema<{
+                    readonly code: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly provider: v.UnionSchema<[v.LiteralSchema<"GOOGLE", undefined>, v.LiteralSchema<"OUTLOOK", undefined>], undefined>;
+                    readonly user: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        setSettings: {
+            delta: v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly settings: Omit<v.ObjectSchema<{
+                    readonly color: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+                    readonly entries: {
+                        readonly color: v.OptionalSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                        readonly name: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+                    };
+                    readonly '~standard': v.StandardProps<{
+                        color?: string | undefined;
+                        name?: string | null | undefined;
+                    }, {
+                        color?: string | undefined;
+                        name?: string | null | undefined;
+                    }>;
+                    readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                        color?: string | undefined;
+                        name?: string | null | undefined;
+                    }, v.ObjectIssue | v.StringIssue | v.NonOptionalIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number>>;
+                    readonly '~types'?: {
+                        readonly input: {
+                            color?: string | undefined;
+                            name?: string | null | undefined;
+                        };
+                        readonly output: {
+                            color?: string | undefined;
+                            name?: string | null | undefined;
+                        };
+                        readonly issue: v.ObjectIssue | v.StringIssue | v.NonOptionalIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number>;
+                    } | undefined;
+                };
+            }, undefined>;
+        };
+    };
+    name: "account";
+    pullUrl: "/v1/pv/sync/pull/account";
+    pushUrl: "/v1/pv/sync/push/account";
+    schemaVersion: "v1";
+};
+//# sourceMappingURL=account.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/clients/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAgB5B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFG,CAAA"}

package/dist/clients/account.js

@@ -0,0 +1,93 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../schemas';
+const accountSettingsSchema = v.object({
+    color: marcoSchemas.string.required(),
+    name: marcoSchemas.string.nullable(),
+});
+const aliasSchema = v.object({
+    emailAddress: marcoSchemas.string.email(),
+    id: marcoSchemas.string.required(),
+    name: marcoSchemas.string.nullable(),
+});
+export const account = {
+    model: v.object({
+        aliases: v.object({
+            nonPrimary: v.array(aliasSchema),
+            primary: aliasSchema,
+        }),
+        id: marcoSchemas.string.required(),
+        imapConnectionStatus: marcoSchemas.emailAccount.imapConnectionStatus(),
+        labels: v.array(v.object({
+            id: marcoSchemas.string.required(),
+            path: marcoSchemas.string.required(),
+            specialUse: v.nullable(marcoSchemas.labels.specialUse()),
+        })),
+        mailCounts: v.object({
+            processed: marcoSchemas.number.positiveInteger(),
+            total: marcoSchemas.number.positiveInteger(),
+        }),
+        settings: accountSettingsSchema,
+    }),
+    mutators: {
+        createAccount: {
+            delta: v.object({
+                aliasId: marcoSchemas.string.required(),
+                color: marcoSchemas.string.required(),
+                emailAddress: marcoSchemas.string.email(),
+                id: marcoSchemas.string.required(),
+            }),
+        },
+        createAlias: {
+            delta: v.object({
+                accountId: marcoSchemas.string.required(),
+                alias: aliasSchema,
+            }),
+        },
+        deleteAccount: {
+            delta: v.object({
+                id: marcoSchemas.string.required(),
+            }),
+        },
+        deleteAlias: {
+            delta: v.object({
+                accountId: marcoSchemas.string.required(),
+                aliasId: marcoSchemas.string.required(),
+            }),
+        },
+        setAliasName: {
+            delta: v.object({
+                accountId: marcoSchemas.string.required(),
+                aliasId: marcoSchemas.string.required(),
+                name: marcoSchemas.string.nullable(),
+            }),
+        },
+        setAliasPrimary: {
+            delta: v.object({
+                accountId: marcoSchemas.string.required(),
+                aliasId: marcoSchemas.string.required(),
+            }),
+        },
+        setConnectionConfigImapRaw: {
+            delta: v.object({
+                connectionConfig: marcoSchemas.emailAccount.connectionConfigImapRaw(),
+                id: marcoSchemas.string.required(),
+            }),
+        },
+        setConnectionConfigOauth: {
+            delta: v.object({
+                connectionConfig: marcoSchemas.emailAccount.connectionConfigOauth(),
+                id: marcoSchemas.string.required(),
+            }),
+        },
+        setSettings: {
+            delta: v.object({
+                id: marcoSchemas.string.required(),
+                settings: v.partial(accountSettingsSchema),
+            }),
+        },
+    },
+    name: 'account',
+    pullUrl: '/v1/pv/sync/pull/account',
+    pushUrl: '/v1/pv/sync/push/account',
+    schemaVersion: 'v1',
+};

package/dist/clients/contact.d.ts

@@ -0,0 +1,14 @@
+import * as v from 'valibot';
+export declare const contact: {
+    model: v.ObjectSchema<{
+        readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>;
+    mutators: {};
+    name: "contact";
+    pullUrl: "/v1/pv/sync/pull/contact";
+    pushUrl: null;
+    schemaVersion: "v1";
+};
+//# sourceMappingURL=contact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contact.d.ts","sourceRoot":"","sources":["../../src/clients/contact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,OAAO;;;;;;;;;;;CAWG,CAAA"}

package/dist/clients/contact.js

@@ -0,0 +1,14 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../schemas';
+export const contact = {
+    model: v.object({
+        emailAddress: marcoSchemas.string.email(),
+        id: marcoSchemas.string.required(),
+        name: marcoSchemas.string.nullable(),
+    }),
+    mutators: {},
+    name: 'contact',
+    pullUrl: '/v1/pv/sync/pull/contact',
+    pushUrl: null,
+    schemaVersion: 'v1',
+};

package/dist/clients/draft.d.ts

@@ -0,0 +1,196 @@
+import * as v from 'valibot';
+export declare const draft: {
+    model: v.ObjectSchema<{
+        readonly attachments: v.ArraySchema<v.ObjectSchema<{
+            readonly failed: v.BooleanSchema<undefined>;
+            readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly totalChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly totalSize: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly uploadedChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+        readonly body: v.ObjectSchema<{
+            readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 384000, undefined>]>;
+            readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+        }, undefined>;
+        readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly error: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly from: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly fromName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly scheduledFor: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+        readonly status: v.PicklistSchema<readonly ["DRAFT", "SEND_REQUESTED", "SEND_CONFIRMED", "SEND_FAILED"], undefined>;
+        readonly type: v.PicklistSchema<readonly ["NEW", "REPLY", "FORWARD"], undefined>;
+        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>;
+    mutators: {
+        cancelSend: {
+            delta: v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        createAttachment: {
+            delta: v.ObjectSchema<{
+                readonly attachment: v.ObjectSchema<{
+                    readonly failed: v.BooleanSchema<undefined>;
+                    readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly totalChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly totalSize: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly uploadedChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                }, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        createDraft: {
+            delta: v.ObjectSchema<{
+                readonly attachments: v.ArraySchema<v.ObjectSchema<{
+                    readonly failed: v.BooleanSchema<undefined>;
+                    readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly totalChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly totalSize: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly uploadedChunks: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                }, undefined>, undefined>;
+                readonly body: v.ObjectSchema<{
+                    readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 384000, undefined>]>;
+                    readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                }, undefined>;
+                readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly error: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly from: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly fromName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly scheduledFor: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+                readonly status: v.PicklistSchema<readonly ["DRAFT", "SEND_REQUESTED", "SEND_CONFIRMED", "SEND_FAILED"], undefined>;
+                readonly type: v.PicklistSchema<readonly ["NEW", "REPLY", "FORWARD"], undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        deleteAttachment: {
+            delta: v.ObjectSchema<{
+                readonly attachmentId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        deleteDraft: {
+            delta: v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        scheduleSend: {
+            delta: v.UnionSchema<[v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly kind: v.LiteralSchema<"IMMEDIATE", undefined>;
+                readonly undoMs: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly kind: v.LiteralSchema<"SCHEDULED", undefined>;
+                readonly scheduledFor: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>], undefined>;
+        };
+        setContent: {
+            delta: v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly patch: v.ArraySchema<v.ObjectSchema<{
+                    readonly index: v.NumberSchema<undefined>;
+                    readonly type: v.UnionSchema<[v.LiteralSchema<"INSERTION", undefined>, v.LiteralSchema<"DELETION", undefined>], undefined>;
+                    readonly value: v.StringSchema<undefined>;
+                }, undefined>, undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        setEnvelope: {
+            delta: v.ObjectSchema<{
+                readonly envelope: Omit<v.ObjectSchema<{
+                    readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 384000, undefined>]>;
+                    readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+                    readonly entries: Omit<{
+                        readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 384000, undefined>]>;
+                        readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    }, "content">;
+                    readonly '~standard': v.StandardProps<{
+                        bcc: string[];
+                        cc: string[];
+                        to: string[];
+                        subject: string | null;
+                    }, {
+                        bcc: string[];
+                        cc: string[];
+                        to: string[];
+                        subject: string | null;
+                    }>;
+                    readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                        bcc: string[];
+                        cc: string[];
+                        to: string[];
+                        subject: string | null;
+                    }, v.ObjectIssue | v.StringIssue | v.ArrayIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonOptionalIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number>>;
+                    readonly '~types'?: {
+                        readonly input: {
+                            bcc: string[];
+                            cc: string[];
+                            to: string[];
+                            subject: string | null;
+                        };
+                        readonly output: {
+                            bcc: string[];
+                            cc: string[];
+                            to: string[];
+                            subject: string | null;
+                        };
+                        readonly issue: v.ObjectIssue | v.StringIssue | v.ArrayIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonOptionalIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number>;
+                    } | undefined;
+                };
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        setFrom: {
+            delta: v.ObjectSchema<{
+                readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly from: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly fromName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        uploadAttachmentChunk: {
+            delta: v.ObjectSchema<{
+                readonly attachmentId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly chunk: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+                readonly chunkIndex: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+    };
+    name: "draft";
+    pullUrl: "/v1/pv/sync/pull/draft";
+    pushUrl: "/v1/pv/sync/push/draft";
+    schemaVersion: "v1";
+};
+//# sourceMappingURL=draft.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../src/clients/draft.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AA0D5B,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEK,CAAA"}

package/dist/clients/draft.js

@@ -0,0 +1,122 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../schemas';
+import { DRAFT_STATUSES, DRAFT_TYPES } from '../types';
+const draftStatusSchema = v.picklist(DRAFT_STATUSES);
+const draftTypeSchema = v.picklist(DRAFT_TYPES);
+const bodySchema = v.object({
+    bcc: v.array(marcoSchemas.string.email()),
+    cc: v.array(marcoSchemas.string.email()),
+    content: v.pipe(v.string(), v.maxLength(384000)),
+    subject: marcoSchemas.string.nullable(),
+    to: v.array(marcoSchemas.string.email()),
+});
+const attachmentSchema = v.object({
+    failed: v.boolean(),
+    fileName: marcoSchemas.string.required(),
+    id: marcoSchemas.string.required(),
+    mimeType: marcoSchemas.string.required(),
+    totalChunks: marcoSchemas.number.positiveInteger(),
+    totalSize: marcoSchemas.number.positiveInteger(),
+    uploadedChunks: marcoSchemas.number.positiveInteger(),
+});
+const scheduledForSchema = v.nullable(marcoSchemas.number.positiveInteger());
+const scheduleSchema = v.union([
+    v.object({
+        id: marcoSchemas.string.required(),
+        kind: v.literal('IMMEDIATE'),
+        undoMs: marcoSchemas.number.positiveInteger(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }),
+    v.object({
+        id: marcoSchemas.string.required(),
+        kind: v.literal('SCHEDULED'),
+        scheduledFor: marcoSchemas.number.positiveInteger(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }),
+]);
+const draftSchema = v.object({
+    attachments: v.array(attachmentSchema),
+    body: bodySchema,
+    emailAccountId: marcoSchemas.string.required(),
+    error: marcoSchemas.string.nullable(),
+    from: marcoSchemas.string.email(),
+    fromName: marcoSchemas.string.nullable(),
+    id: marcoSchemas.string.required(),
+    referencedMessageId: marcoSchemas.string.nullable(),
+    scheduledFor: scheduledForSchema,
+    status: draftStatusSchema,
+    type: draftTypeSchema,
+    updatedAt: marcoSchemas.number.positiveInteger(),
+});
+export const draft = {
+    model: draftSchema,
+    mutators: {
+        cancelSend: {
+            delta: v.object({
+                id: marcoSchemas.string.required(),
+                updatedAt: marcoSchemas.number.positiveInteger(),
+            }),
+        },
+        createAttachment: {
+            delta: v.object({
+                attachment: attachmentSchema,
+                id: marcoSchemas.string.required(),
+                updatedAt: marcoSchemas.number.positiveInteger(),
+            }),
+        },
+        createDraft: {
+            delta: draftSchema,
+        },
+        deleteAttachment: {
+            delta: v.object({
+                attachmentId: marcoSchemas.string.required(),
+                id: marcoSchemas.string.required(),
+                updatedAt: marcoSchemas.number.positiveInteger(),
+            }),
+        },
+        deleteDraft: {
+            delta: v.object({
+                id: marcoSchemas.string.required(),
+            }),
+        },
+        scheduleSend: {
+            delta: scheduleSchema,
+        },
+        setContent: {
+            delta: v.object({
+                id: marcoSchemas.string.required(),
+                patch: marcoSchemas.drafts.contentPatch.patch(),
+                updatedAt: marcoSchemas.number.positiveInteger(),
+            }),
+        },
+        setEnvelope: {
+            delta: v.object({
+                envelope: v.omit(bodySchema, ['content']),
+                id: marcoSchemas.string.required(),
+                updatedAt: marcoSchemas.number.positiveInteger(),
+            }),
+        },
+        setFrom: {
+            delta: v.object({
+                aliasId: marcoSchemas.string.required(),
+                emailAccountId: marcoSchemas.string.required(),
+                from: marcoSchemas.string.email(),
+                fromName: marcoSchemas.string.nullable(),
+                id: marcoSchemas.string.required(),
+                updatedAt: marcoSchemas.number.positiveInteger(),
+            }),
+        },
+        uploadAttachmentChunk: {
+            delta: v.object({
+                attachmentId: marcoSchemas.string.required(),
+                chunk: v.pipe(v.string(), v.base64()),
+                chunkIndex: marcoSchemas.number.positiveInteger(),
+                id: marcoSchemas.string.required(),
+            }),
+        },
+    },
+    name: 'draft',
+    pullUrl: '/v1/pv/sync/pull/draft',
+    pushUrl: '/v1/pv/sync/push/draft',
+    schemaVersion: 'v1',
+};