@marcoappio/marco-config 2.0.158 → 2.0.160

package/dist/clients/draft.d.ts

@@ -0,0 +1,107 @@
+import * as v from 'valibot';
+export declare const draft: {
+    model: v.ObjectSchema<{
+        readonly body: v.ObjectSchema<{
+            readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly content: v.UnknownSchema;
+            readonly replyTo: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly subject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+        }, undefined>;
+        readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+    }, undefined>;
+    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.UnknownSchema;
+                    readonly replyTo: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly subject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                }, undefined>;
+                readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        delete: {
+            delta: v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        update: {
+            delta: v.ObjectSchema<{
+                readonly body: Omit<v.ObjectSchema<{
+                    readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly content: v.UnknownSchema;
+                    readonly replyTo: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    readonly subject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                }, undefined>, "entries" | "~standard" | "~run" | "~types"> & {
+                    readonly entries: {
+                        readonly bcc: v.OptionalSchema<v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                        readonly cc: v.OptionalSchema<v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                        readonly content: v.OptionalSchema<v.UnknownSchema, undefined>;
+                        readonly replyTo: v.OptionalSchema<v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                        readonly subject: v.OptionalSchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly to: v.OptionalSchema<v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                    };
+                    readonly '~standard': v.StandardSchemaProps<{
+                        bcc?: string[] | undefined;
+                        cc?: string[] | undefined;
+                        replyTo?: string[] | undefined;
+                        to?: string[] | undefined;
+                        content?: unknown;
+                        subject?: string | undefined;
+                    }, {
+                        bcc?: string[] | undefined;
+                        cc?: string[] | undefined;
+                        replyTo?: string[] | undefined;
+                        to?: string[] | undefined;
+                        content?: unknown;
+                        subject?: string | undefined;
+                    }>;
+                    readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                        bcc?: string[] | undefined;
+                        cc?: string[] | undefined;
+                        replyTo?: string[] | undefined;
+                        to?: string[] | undefined;
+                        content?: unknown;
+                        subject?: string | undefined;
+                    }, v.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ObjectIssue | v.NonOptionalIssue | v.ArrayIssue>;
+                    readonly '~types'?: {
+                        readonly input: {
+                            bcc?: string[] | undefined;
+                            cc?: string[] | undefined;
+                            replyTo?: string[] | undefined;
+                            to?: string[] | undefined;
+                            content?: unknown;
+                            subject?: string | undefined;
+                        };
+                        readonly output: {
+                            bcc?: string[] | undefined;
+                            cc?: string[] | undefined;
+                            replyTo?: string[] | undefined;
+                            to?: string[] | undefined;
+                            content?: unknown;
+                            subject?: string | undefined;
+                        };
+                        readonly issue: v.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ObjectIssue | v.NonOptionalIssue | v.ArrayIssue;
+                    } | undefined;
+                };
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>;
+        };
+    };
+    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;AAc5B,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCK,CAAA"}

package/dist/clients/draft.js

@@ -0,0 +1,43 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../schemas';
+const body = v.object({
+    bcc: v.array(marcoSchemas.string.email()),
+    cc: v.array(marcoSchemas.string.email()),
+    content: v.unknown(),
+    replyTo: v.array(marcoSchemas.string.email()),
+    subject: marcoSchemas.string.required(),
+    to: v.array(marcoSchemas.string.email()),
+});
+export const draft = {
+    model: v.object({
+        body: body,
+        emailAccountId: marcoSchemas.string.required(),
+        id: marcoSchemas.string.required(),
+        referencedMessageId: marcoSchemas.string.nullable(),
+    }),
+    mutators: {
+        create: {
+            delta: v.object({
+                body: body,
+                emailAccountId: marcoSchemas.string.required(),
+                id: marcoSchemas.string.required(),
+                referencedMessageId: marcoSchemas.string.nullable(),
+            }),
+        },
+        delete: {
+            delta: v.object({
+                id: marcoSchemas.string.required(),
+            }),
+        },
+        update: {
+            delta: v.object({
+                body: v.partial(body),
+                id: marcoSchemas.string.required(),
+            }),
+        },
+    },
+    name: 'draft',
+    pullURL: '/v1/pv/sync/pull/draft',
+    pushURL: '/v1/pv/sync/push/draft',
+    schemaVersion: 'v1',
+};

package/dist/clients/index.d.ts

@@ -111,6 +111,111 @@ export declare const marcoClients: {
         pushURL: null;
         schemaVersion: "v1";
     };
+    draft: {
+        model: import("valibot").ObjectSchema<{
+            readonly body: import("valibot").ObjectSchema<{
+                readonly bcc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly cc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly content: import("valibot").UnknownSchema;
+                readonly replyTo: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            }, undefined>;
+            readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+        }, undefined>;
+        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").UnknownSchema;
+                        readonly replyTo: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    }, undefined>;
+                    readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>;
+            };
+            delete: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>;
+            };
+            update: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly body: Omit<import("valibot").ObjectSchema<{
+                        readonly bcc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly cc: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly content: import("valibot").UnknownSchema;
+                        readonly replyTo: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                        readonly subject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                    }, undefined>, "entries" | "~standard" | "~run" | "~types"> & {
+                        readonly entries: {
+                            readonly bcc: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                            readonly cc: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                            readonly content: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                            readonly replyTo: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                            readonly subject: import("valibot").OptionalSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                            readonly to: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>, undefined>;
+                        };
+                        readonly '~standard': import("valibot").StandardSchemaProps<{
+                            bcc?: string[] | undefined;
+                            cc?: string[] | undefined;
+                            replyTo?: string[] | undefined;
+                            to?: string[] | undefined;
+                            content?: unknown;
+                            subject?: string | undefined;
+                        }, {
+                            bcc?: string[] | undefined;
+                            cc?: string[] | undefined;
+                            replyTo?: string[] | undefined;
+                            to?: string[] | undefined;
+                            content?: unknown;
+                            subject?: string | undefined;
+                        }>;
+                        readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+                            bcc?: string[] | undefined;
+                            cc?: string[] | undefined;
+                            replyTo?: string[] | undefined;
+                            to?: string[] | undefined;
+                            content?: unknown;
+                            subject?: string | undefined;
+                        }, import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue>;
+                        readonly '~types'?: {
+                            readonly input: {
+                                bcc?: string[] | undefined;
+                                cc?: string[] | undefined;
+                                replyTo?: string[] | undefined;
+                                to?: string[] | undefined;
+                                content?: unknown;
+                                subject?: string | undefined;
+                            };
+                            readonly output: {
+                                bcc?: string[] | undefined;
+                                cc?: string[] | undefined;
+                                replyTo?: string[] | undefined;
+                                to?: string[] | undefined;
+                                content?: unknown;
+                                subject?: string | undefined;
+                            };
+                            readonly issue: import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue;
+                        } | undefined;
+                    };
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>;
+            };
+        };
+        name: "draft";
+        pullURL: "/v1/pv/sync/pull/draft";
+        pushURL: "/v1/pv/sync/push/draft";
+        schemaVersion: "v1";
+    };
     thread: {
         model: import("valibot").ObjectSchema<{
             readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<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":"AAOA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKc,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/index.js

@@ -1,11 +1,13 @@
 import { account } from './account';
 import { contact } from './contact';
+import { draft } from './draft';
 import { thread } from './thread';
 import { user } from './user';
 export { marcoClientsUtils } from './utils';
 export const marcoClients = {
     account,
     contact,
+    draft,
     thread,
     user,
 };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
+export { accountUtils } from './utils';
 export { marcoClients, marcoClientsUtils } from './clients';
 export { marcoPublicConfig, MARCO_ENV, MarcoEnvironment } from './marcoPublicConfig';
-export { marcoSDK } from './sdk';
-export { MarcoWSEvent, MarcoClient, MarcoWSSyncPoke, EndpointConfig, EndpointError, EndpointResponse, LabelSpecialUse } from './types';
 export { marcoSchemas } from './schemas';
+export { marcoSDK } from './sdk';
 export { marcoWS } from './ws';
+export { MarcoWSEvent, MarcoClient, MarcoWSSyncPoke, EndpointConfig, EndpointError, EndpointResponse, LabelSpecialUse } from './types';
 //# sourceMappingURL=index.d.ts.map

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,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACtI,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA"}
+{"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"}

package/dist/index.js

@@ -1,5 +1,6 @@
+export { accountUtils } from './utils';
 export { marcoClients, marcoClientsUtils } from './clients';
 export { marcoPublicConfig, MARCO_ENV } from './marcoPublicConfig';
-export { marcoSDK } from './sdk';
 export { marcoSchemas } from './schemas';
+export { marcoSDK } from './sdk';
 export { marcoWS } from './ws';

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC,OAAO,EAAE,cAAc,EAAoB,MAAM,qBAAqB,CAAA;AActE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC,OAAO,EAAE,cAAc,EAAoB,MAAM,qBAAqB,CAAA;AActE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}