@marcoappio/marco-config 2.0.408 → 2.0.409

package/dist/clients/account.d.ts

@@ -1,144 +0,0 @@
-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.UnionSchema<[v.LiteralSchema<"AWAITING_CONNECTION", undefined>, v.LiteralSchema<"CONNECTED", undefined>, v.LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_QUOTA_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], 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.UnionSchema<[v.LiteralSchema<"ARCHIVE", undefined>, v.LiteralSchema<"INBOX", undefined>, v.LiteralSchema<"SENT", undefined>, v.LiteralSchema<"SPAM", undefined>, v.LiteralSchema<"TRASH", undefined>], 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>, "~standard" | "~run" | "~types" | "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.StringIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.ObjectIssue>;
-                    readonly '~types'?: {
-                        readonly input: {
-                            color?: string | undefined;
-                            name?: string | null | undefined;
-                        };
-                        readonly output: {
-                            color?: string | undefined;
-                            name?: string | null | undefined;
-                        };
-                        readonly issue: v.StringIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.ObjectIssue;
-                    } | 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

@@ -1 +0,0 @@
-{"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

@@ -1,93 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,14 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SEND_REQUESTED", undefined>, v.LiteralSchema<"SEND_CONFIRMED", undefined>, v.LiteralSchema<"SEND_FAILED", undefined>], undefined>;
-        readonly type: v.UnionSchema<[v.LiteralSchema<"NEW", undefined>, v.LiteralSchema<"REPLY", undefined>, v.LiteralSchema<"FORWARD", undefined>], undefined>;
-        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<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.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SEND_REQUESTED", undefined>, v.LiteralSchema<"SEND_CONFIRMED", undefined>, v.LiteralSchema<"SEND_FAILED", undefined>], undefined>;
-                readonly type: v.UnionSchema<[v.LiteralSchema<"NEW", undefined>, v.LiteralSchema<"REPLY", undefined>, v.LiteralSchema<"FORWARD", undefined>], undefined>;
-                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<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>;
-        };
-        sendDraft: {
-            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>;
-        };
-        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>, "~standard" | "~run" | "~types" | "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.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.ObjectIssue | v.ArrayIssue>;
-                    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.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.ObjectIssue | v.ArrayIssue;
-                    } | 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

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

package/dist/clients/draft.js

@@ -1,137 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../schemas';
-const draftStatusSchema = v.union([
-    v.literal('DRAFT'),
-    v.literal('SEND_REQUESTED'),
-    v.literal('SEND_CONFIRMED'),
-    v.literal('SEND_FAILED'),
-]);
-const draftTypeSchema = v.union([
-    v.literal('NEW'),
-    v.literal('REPLY'),
-    v.literal('FORWARD'),
-]);
-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,
-        },
-        // TODO: Remove/deprecate
-        sendDraft: {
-            delta: v.object({
-                id: marcoSchemas.string.required(),
-                updatedAt: marcoSchemas.number.positiveInteger(),
-            }),
-        },
-        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',
-};