@marcoappio/marco-config 2.0.169 → 2.0.171

package/dist/clients/account.d.ts

@@ -56,7 +56,7 @@ export declare const account: {
                     readonly color: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly firstName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly lastName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-                }, undefined>, "entries" | "~standard" | "~run" | "~types"> & {
+                }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                     readonly entries: {
                         readonly color: v.OptionalSchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                         readonly firstName: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
@@ -75,7 +75,7 @@ export declare const account: {
                         color?: string | undefined;
                         firstName?: string | null | undefined;
                         lastName?: string | null | undefined;
-                    }, v.StringIssue | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ObjectIssue | v.NonOptionalIssue>;
+                    }, v.StringIssue | v.ObjectIssue | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.NonOptionalIssue>;
                     readonly '~types'?: {
                         readonly input: {
                             color?: string | undefined;
@@ -87,7 +87,7 @@ export declare const account: {
                             firstName?: string | null | undefined;
                             lastName?: string | null | undefined;
                         };
-                        readonly issue: v.StringIssue | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ObjectIssue | v.NonOptionalIssue;
+                        readonly issue: v.StringIssue | v.ObjectIssue | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.NonOptionalIssue;
                     } | undefined;
                 };
             }, undefined>;

package/dist/clients/draft.d.ts

@@ -14,23 +14,91 @@ export declare const draft: {
         readonly status: v.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SENDING", undefined>, v.LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
     }, undefined>;
     mutators: {
+        create: {
+            delta: v.ObjectSchema<{
+                readonly body: v.ObjectSchema<{
+                    readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly content: v.StringSchema<undefined>;
+                    readonly subject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                }, undefined>;
+                readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.UuidAction<string, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.UuidAction<string, undefined>]>, undefined>;
+                readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly status: v.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SENDING", undefined>, v.LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
+            }, undefined>;
+        };
         delete: {
             delta: v.ObjectSchema<{
                 readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.UuidAction<string, undefined>]>, undefined>;
             }, undefined>;
         };
-        upsert: {
+        setContent: {
             delta: v.ObjectSchema<{
-                readonly body: v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.UuidAction<string, 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>;
+            }, undefined>;
+        };
+        setEnvelope: {
+            delta: v.ObjectSchema<{
+                readonly envelope: Omit<v.ObjectSchema<{
                     readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                     readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                     readonly content: v.StringSchema<undefined>;
                     readonly subject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
-                }, undefined>;
-                readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.UuidAction<string, undefined>]>, undefined>;
+                }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+                    readonly entries: Omit<{
+                        readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly content: v.StringSchema<undefined>;
+                        readonly subject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    }, "content">;
+                    readonly '~standard': v.StandardSchemaProps<{
+                        bcc: string[];
+                        cc: string[];
+                        to: string[];
+                        subject: string;
+                    }, {
+                        bcc: string[];
+                        cc: string[];
+                        to: string[];
+                        subject: string;
+                    }>;
+                    readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                        bcc: string[];
+                        cc: string[];
+                        to: string[];
+                        subject: string;
+                    }, v.StringIssue | v.ObjectIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ArrayIssue | v.NonOptionalIssue>;
+                    readonly '~types'?: {
+                        readonly input: {
+                            bcc: string[];
+                            cc: string[];
+                            to: string[];
+                            subject: string;
+                        };
+                        readonly output: {
+                            bcc: string[];
+                            cc: string[];
+                            to: string[];
+                            subject: string;
+                        };
+                        readonly issue: v.StringIssue | v.ObjectIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ArrayIssue | v.NonOptionalIssue;
+                    } | undefined;
+                };
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.UuidAction<string, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        setStatus: {
+            delta: v.ObjectSchema<{
                 readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.UuidAction<string, undefined>]>, undefined>;
-                readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly status: v.UnionSchema<[v.LiteralSchema<"DRAFT", undefined>, v.LiteralSchema<"SENDING", undefined>, v.LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
             }, undefined>;
         };

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

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

package/dist/clients/draft.js

@@ -1,32 +1,52 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../schemas';
+const draftStatusSchema = v.union([
+    v.literal('DRAFT'),
+    v.literal('SENDING'),
+    v.literal('SENDING_FAILED'),
+]);
+const bodySchema = v.object({
+    bcc: v.array(marcoSchemas.string.email()),
+    cc: v.array(marcoSchemas.string.email()),
+    content: v.string(),
+    subject: marcoSchemas.string.required(),
+    to: v.array(marcoSchemas.string.email()),
+});
 const draftSchema = v.object({
-    body: v.object({
-        bcc: v.array(marcoSchemas.string.email()),
-        cc: v.array(marcoSchemas.string.email()),
-        content: v.string(),
-        subject: marcoSchemas.string.required(),
-        to: v.array(marcoSchemas.string.email()),
-    }),
+    body: bodySchema,
     emailAccountId: marcoSchemas.string.uuid(),
     id: marcoSchemas.string.uuid(),
     referencedMessageId: marcoSchemas.string.nullable(),
-    status: v.union([
-        v.literal('DRAFT'),
-        v.literal('SENDING'),
-        v.literal('SENDING_FAILED'),
-    ]),
+    status: draftStatusSchema,
 });
 export const draft = {
     model: draftSchema,
     mutators: {
+        create: {
+            delta: draftSchema,
+        },
         delete: {
             delta: v.object({
                 id: marcoSchemas.string.uuid(),
             }),
         },
-        upsert: {
-            delta: draftSchema,
+        setContent: {
+            delta: v.object({
+                id: marcoSchemas.string.uuid(),
+                patch: marcoSchemas.drafts.contentPatch.patch(),
+            }),
+        },
+        setEnvelope: {
+            delta: v.object({
+                envelope: v.omit(bodySchema, ['content']),
+                id: marcoSchemas.string.uuid(),
+            }),
+        },
+        setStatus: {
+            delta: v.object({
+                id: marcoSchemas.string.uuid(),
+                status: draftStatusSchema,
+            }),
         },
     },
     name: 'draft',

package/dist/clients/index.d.ts

@@ -57,7 +57,7 @@ export declare const marcoClients: {
                         readonly color: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-                    }, undefined>, "entries" | "~standard" | "~run" | "~types"> & {
+                    }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                         readonly entries: {
                             readonly color: import("valibot").OptionalSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                             readonly firstName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
@@ -76,7 +76,7 @@ export declare const marcoClients: {
                             color?: string | undefined;
                             firstName?: string | null | undefined;
                             lastName?: string | null | undefined;
-                        }, import("valibot").StringIssue | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").NonOptionalIssue>;
+                        }, import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").NonOptionalIssue>;
                         readonly '~types'?: {
                             readonly input: {
                                 color?: string | undefined;
@@ -88,7 +88,7 @@ export declare const marcoClients: {
                                 firstName?: string | null | undefined;
                                 lastName?: string | null | undefined;
                             };
-                            readonly issue: import("valibot").StringIssue | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").NonOptionalIssue;
+                            readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").NonOptionalIssue;
                         } | undefined;
                     };
                 }, undefined>;
@@ -126,23 +126,91 @@ export declare const marcoClients: {
             readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SENDING", undefined>, import("valibot").LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
         }, undefined>;
         mutators: {
+            create: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly body: import("valibot").ObjectSchema<{
+                        readonly bcc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly cc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly content: import("valibot").StringSchema<undefined>;
+                        readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    }, undefined>;
+                    readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").UuidAction<string, undefined>]>, undefined>;
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").UuidAction<string, undefined>]>, undefined>;
+                    readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SENDING", undefined>, import("valibot").LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
+                }, undefined>;
+            };
             delete: {
                 delta: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").UuidAction<string, undefined>]>, undefined>;
                 }, undefined>;
             };
-            upsert: {
+            setContent: {
                 delta: import("valibot").ObjectSchema<{
-                    readonly body: import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").UuidAction<string, undefined>]>, undefined>;
+                    readonly patch: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly index: import("valibot").NumberSchema<undefined>;
+                        readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"INSERTION", undefined>, import("valibot").LiteralSchema<"DELETION", undefined>], undefined>;
+                        readonly value: import("valibot").StringSchema<undefined>;
+                    }, undefined>, undefined>;
+                }, undefined>;
+            };
+            setEnvelope: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly envelope: Omit<import("valibot").ObjectSchema<{
                         readonly bcc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                         readonly cc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                         readonly content: import("valibot").StringSchema<undefined>;
                         readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
-                    }, undefined>;
-                    readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").UuidAction<string, undefined>]>, undefined>;
+                    }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+                        readonly entries: Omit<{
+                            readonly bcc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                            readonly cc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                            readonly content: import("valibot").StringSchema<undefined>;
+                            readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        }, "content">;
+                        readonly '~standard': import("valibot").StandardSchemaProps<{
+                            bcc: string[];
+                            cc: string[];
+                            to: string[];
+                            subject: string;
+                        }, {
+                            bcc: string[];
+                            cc: string[];
+                            to: string[];
+                            subject: string;
+                        }>;
+                        readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+                            bcc: string[];
+                            cc: string[];
+                            to: string[];
+                            subject: string;
+                        }, import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ArrayIssue | import("valibot").NonOptionalIssue>;
+                        readonly '~types'?: {
+                            readonly input: {
+                                bcc: string[];
+                                cc: string[];
+                                to: string[];
+                                subject: string;
+                            };
+                            readonly output: {
+                                bcc: string[];
+                                cc: string[];
+                                to: string[];
+                                subject: string;
+                            };
+                            readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ArrayIssue | import("valibot").NonOptionalIssue;
+                        } | undefined;
+                    };
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").UuidAction<string, undefined>]>, undefined>;
+                }, undefined>;
+            };
+            setStatus: {
+                delta: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").UuidAction<string, undefined>]>, undefined>;
-                    readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"DRAFT", undefined>, import("valibot").LiteralSchema<"SENDING", undefined>, import("valibot").LiteralSchema<"SENDING_FAILED", undefined>], undefined>;
                 }, undefined>;
             };
@@ -215,7 +283,7 @@ export declare const marcoClients: {
                     readonly settings: Omit<import("valibot").ObjectSchema<{
                         readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-                    }, undefined>, "entries" | "~standard" | "~run" | "~types"> & {
+                    }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                         readonly entries: {
                             readonly firstName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                             readonly lastName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
@@ -230,7 +298,7 @@ export declare const marcoClients: {
                         readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
                             firstName?: string | null | undefined;
                             lastName?: string | null | undefined;
-                        }, import("valibot").StringIssue | import("valibot").MaxLengthIssue<string, 255> | import("valibot").ObjectIssue>;
+                        }, import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, 255>>;
                         readonly '~types'?: {
                             readonly input: {
                                 firstName?: string | null | undefined;
@@ -240,7 +308,7 @@ export declare const marcoClients: {
                                 firstName?: string | null | undefined;
                                 lastName?: string | null | undefined;
                             };
-                            readonly issue: import("valibot").StringIssue | import("valibot").MaxLengthIssue<string, 255> | import("valibot").ObjectIssue;
+                            readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue | import("valibot").MaxLengthIssue<string, 255>;
                         } | undefined;
                     };
                 }, undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clients/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clients/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMc,CAAA"}

package/dist/clients/user.d.ts

@@ -14,7 +14,7 @@ export declare const user: {
                 readonly settings: Omit<v.ObjectSchema<{
                     readonly firstName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly lastName: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-                }, undefined>, "entries" | "~standard" | "~run" | "~types"> & {
+                }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
                     readonly entries: {
                         readonly firstName: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                         readonly lastName: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
@@ -29,7 +29,7 @@ export declare const user: {
                     readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
                         firstName?: string | null | undefined;
                         lastName?: string | null | undefined;
-                    }, v.StringIssue | v.MaxLengthIssue<string, 255> | v.ObjectIssue>;
+                    }, v.StringIssue | v.ObjectIssue | v.MaxLengthIssue<string, 255>>;
                     readonly '~types'?: {
                         readonly input: {
                             firstName?: string | null | undefined;
@@ -39,7 +39,7 @@ export declare const user: {
                             firstName?: string | null | undefined;
                             lastName?: string | null | undefined;
                         };
-                        readonly issue: v.StringIssue | v.MaxLengthIssue<string, 255> | v.ObjectIssue;
+                        readonly issue: v.StringIssue | v.ObjectIssue | v.MaxLengthIssue<string, 255>;
                     } | undefined;
                 };
             }, undefined>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { accountUtils } from './utils';
+export { accountUtils, stringPatch } from './utils';
 export { marcoClients, marcoClientsUtils } from './clients';
 export { marcoPublicConfig, MARCO_ENV, MarcoEnvironment } from './marcoPublicConfig';
 export { marcoSchemas } from './schemas';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAC9B,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACnD,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAC9B,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -1,4 +1,4 @@
-export { accountUtils } from './utils';
+export { accountUtils, stringPatch } from './utils';
 export { marcoClients, marcoClientsUtils } from './clients';
 export { marcoPublicConfig, MARCO_ENV } from './marcoPublicConfig';
 export { marcoSchemas } from './schemas';

package/dist/schemas.d.ts

@@ -1,18 +1,33 @@
+import * as v from 'valibot';
 export declare const marcoSchemas: {
-    emailAccountConnectionState: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED", undefined>], undefined>;
-    labelSpecialUse: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>;
+    drafts: {
+        contentPatch: {
+            instruction: () => 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>;
+            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>;
+        };
+    };
+    emailAccountConnectionState: () => v.UnionSchema<[v.LiteralSchema<"AWAITING_CONNECTION", undefined>, v.LiteralSchema<"CONNECTED", undefined>, v.LiteralSchema<"CONNECTION_FAILED", undefined>], undefined>;
+    labelSpecialUse: () => v.UnionSchema<[v.LiteralSchema<"ARCHIVE", undefined>, v.LiteralSchema<"INBOX", undefined>, v.LiteralSchema<"SENT", undefined>, v.LiteralSchema<"SPAM", undefined>, v.LiteralSchema<"TRASH", undefined>], undefined>;
     number: {
-        minMax: (min: number, max: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-        positiveInteger: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+        minMax: (min: number, max: number) => v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
+        positiveInteger: () => v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     };
     string: {
-        email: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-        enum: (values: Record<string, string>) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EnumSchema<Record<string, string>, undefined>]>, undefined>;
-        matches: (regex: RegExp) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, undefined>]>, undefined>;
-        nullable: () => import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-        optional: () => import("valibot").UndefinedableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-        required: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-        uuid: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").UuidAction<string, undefined>]>, undefined>;
+        email: () => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        enum: (values: Record<string, string>) => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EnumSchema<Record<string, string>, undefined>]>, undefined>;
+        matches: (regex: RegExp) => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
+        nullable: () => v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        optional: () => v.UndefinedableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        required: () => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        uuid: () => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.UuidAction<string, undefined>]>, undefined>;
     };
 };
 //# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;sBAcP,MAAM,OAAO,MAAM;;;;;uBAQlB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;yBAEpB,MAAM;;;;;;CAW1B,CAAA"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAW5B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;sBAoBP,MAAM,OAAO,MAAM;;;;;uBAQlB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;yBAEpB,MAAM;;;;;;CAW1B,CAAA"}

package/dist/schemas.js

@@ -1,28 +1,42 @@
-import { email, enum as enumValidator, integer, literal, maxLength, maxValue, minValue, nonEmpty, nonOptional, nullable, number, pipe, string, undefinedable, union, uuid, regex as v_regex } from 'valibot';
+import * as v from 'valibot';
+const patchInstructionSchema = v.object({
+    index: v.number(),
+    type: v.union([
+        v.literal('INSERTION'),
+        v.literal('DELETION'),
+    ]),
+    value: v.string(),
+});
 export const marcoSchemas = {
-    emailAccountConnectionState: () => union([
-        literal('AWAITING_CONNECTION'),
-        literal('CONNECTED'),
-        literal('CONNECTION_FAILED'),
+    drafts: {
+        contentPatch: {
+            instruction: () => patchInstructionSchema,
+            patch: () => v.array(patchInstructionSchema),
+        },
+    },
+    emailAccountConnectionState: () => v.union([
+        v.literal('AWAITING_CONNECTION'),
+        v.literal('CONNECTED'),
+        v.literal('CONNECTION_FAILED'),
     ]),
-    labelSpecialUse: () => union([
-        literal('ARCHIVE'),
-        literal('INBOX'),
-        literal('SENT'),
-        literal('SPAM'),
-        literal('TRASH'),
+    labelSpecialUse: () => v.union([
+        v.literal('ARCHIVE'),
+        v.literal('INBOX'),
+        v.literal('SENT'),
+        v.literal('SPAM'),
+        v.literal('TRASH'),
     ]),
     number: {
-        minMax: (min, max) => nonOptional(pipe(number(), minValue(min), maxValue(max))),
-        positiveInteger: () => nonOptional(pipe(number(), integer(), minValue(0))),
+        minMax: (min, max) => v.nonOptional(v.pipe(v.number(), v.minValue(min), v.maxValue(max))),
+        positiveInteger: () => v.nonOptional(v.pipe(v.number(), v.integer(), v.minValue(0))),
     },
     string: {
-        email: () => nonOptional(pipe(string(), email(), maxLength(255))),
-        enum: (values) => nonOptional(pipe(string(), enumValidator(values))),
-        matches: (regex) => nonOptional(pipe(string(), v_regex(regex))),
-        nullable: () => nullable(pipe(string(), maxLength(255))),
-        optional: () => undefinedable(pipe(string(), maxLength(255))),
-        required: () => nonOptional(pipe(string(), nonEmpty(), maxLength(255))),
-        uuid: () => nonOptional(pipe(string(), nonEmpty(), uuid())),
+        email: () => v.nonOptional(v.pipe(v.string(), v.email(), v.maxLength(255))),
+        enum: (values) => v.nonOptional(v.pipe(v.string(), v.enum(values))),
+        matches: (regex) => v.nonOptional(v.pipe(v.string(), v.regex(regex))),
+        nullable: () => v.nullable(v.pipe(v.string(), v.maxLength(255))),
+        optional: () => v.undefinedable(v.pipe(v.string(), v.maxLength(255))),
+        required: () => v.nonOptional(v.pipe(v.string(), v.nonEmpty(), v.maxLength(255))),
+        uuid: () => v.nonOptional(v.pipe(v.string(), v.nonEmpty(), v.uuid())),
     },
 };