@marcoappio/marco-config 2.0.159 → 2.0.161

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/draft.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA+BxB,CAAA"}

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

@@ -0,0 +1,36 @@
+import * as v from 'valibot';
+import { draft } from '../../../../../clients/draft';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { errorManifest } from '../../../../../sdk/validation/errors';
+export const syncPushDraft = createEndpoint({
+    body: v.object({
+        clientGroupID: v.string(),
+        mutations: v.array(v.union([
+            v.object({
+                args: draft.mutators.delete.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('delete'),
+            }),
+            v.object({
+                args: draft.mutators.update.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('update'),
+            }),
+            v.object({
+                args: draft.mutators.create.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('create'),
+            }),
+        ])),
+    }),
+    method: 'POST',
+    path: draft.pushURL,
+    response: v.union([
+        errorManifest.validationFailedErrorSchema,
+        errorManifest.authenticationFailedErrorSchema,
+        v.object({ status: v.literal(200) }),
+    ]),
+});

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmC,CAAA"}

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

@@ -1,4 +1,5 @@
 import { syncPushAccount as account } from './account';
+import { syncPushDraft as draft } from './draft';
 import { syncPushThread as thread } from './thread';
 import { syncPushUser as user } from './user';
-export const push = { account, thread, user };
+export const push = { account, draft, thread, user };

package/dist/sdk/index.d.ts

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "2.0.159",
+  "version": "2.0.161",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",