@marcoappio/marco-config 2.0.162 → 2.0.163

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

@@ -1,6 +1,6 @@
 export declare const privateGroup: {
     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<{
+        getHTML: 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<{
@@ -120,7 +120,12 @@ export declare const privateGroup: {
                             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 content: import("valibot").ObjectSchema<{
+                                    readonly content: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+                                        readonly type: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                    }, undefined>, undefined>;
+                                    readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"doc", undefined>], undefined>;
+                                }, undefined>;
                                 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>;
@@ -334,7 +339,12 @@ export declare const privateGroup: {
                         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 content: import("valibot").ObjectSchema<{
+                                readonly content: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+                                    readonly type: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                }, undefined>, undefined>;
+                                readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"doc", undefined>], undefined>;
+                            }, undefined>;
                             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>;
@@ -342,7 +352,12 @@ export declare const privateGroup: {
                             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 content: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                                    readonly content: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+                                        readonly type: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                    }, undefined>, undefined>;
+                                    readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"doc", undefined>], undefined>;
+                                }, undefined>, 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>;
@@ -350,44 +365,79 @@ export declare const privateGroup: {
                             readonly '~standard': import("valibot").StandardSchemaProps<{
                                 bcc?: string[] | undefined;
                                 cc?: string[] | undefined;
+                                content?: {
+                                    type: "doc";
+                                    content: ({
+                                        type: string;
+                                    } & {
+                                        [key: string]: unknown;
+                                    })[];
+                                } | undefined;
                                 replyTo?: string[] | undefined;
                                 to?: string[] | undefined;
-                                content?: unknown;
                                 subject?: string | undefined;
                             }, {
                                 bcc?: string[] | undefined;
                                 cc?: string[] | undefined;
+                                content?: {
+                                    type: "doc";
+                                    content: ({
+                                        type: string;
+                                    } & {
+                                        [key: string]: unknown;
+                                    })[];
+                                } | 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;
+                                content?: {
+                                    type: "doc";
+                                    content: ({
+                                        type: string;
+                                    } & {
+                                        [key: string]: unknown;
+                                    })[];
+                                } | 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>;
+                            }, import("valibot").LiteralIssue | import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").UnionIssue<import("valibot").LiteralIssue> | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue | import("valibot").LooseObjectIssue>;
                             readonly '~types'?: {
                                 readonly input: {
                                     bcc?: string[] | undefined;
                                     cc?: string[] | undefined;
+                                    content?: {
+                                        type: "doc";
+                                        content: ({
+                                            type: string;
+                                        } & {
+                                            [key: string]: unknown;
+                                        })[];
+                                    } | undefined;
                                     replyTo?: string[] | undefined;
                                     to?: string[] | undefined;
-                                    content?: unknown;
                                     subject?: string | undefined;
                                 };
                                 readonly output: {
                                     bcc?: string[] | undefined;
                                     cc?: string[] | undefined;
+                                    content?: {
+                                        type: "doc";
+                                        content: ({
+                                            type: string;
+                                        } & {
+                                            [key: string]: unknown;
+                                        })[];
+                                    } | 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;
+                                readonly issue: import("valibot").LiteralIssue | import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").UnionIssue<import("valibot").LiteralIssue> | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue | import("valibot").LooseObjectIssue;
                             } | 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>;
@@ -400,7 +450,12 @@ export declare const privateGroup: {
                         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 content: import("valibot").ObjectSchema<{
+                                readonly content: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+                                    readonly type: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                }, undefined>, undefined>;
+                                readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"doc", undefined>], undefined>;
+                            }, undefined>;
                             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>;

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

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

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

@@ -1,4 +1,4 @@
-import { emailMessage } from './email-message';
+import { emailMessage } from './emailMessage';
 import { sync } from './sync';
 import { user } from './user';
 export const privateGroup = {

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

@@ -105,7 +105,12 @@ export declare const sync: {
                         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 content: import("valibot").ObjectSchema<{
+                                readonly content: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+                                    readonly type: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                }, undefined>, undefined>;
+                                readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"doc", undefined>], undefined>;
+                            }, undefined>;
                             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>;
@@ -319,7 +324,12 @@ export declare const sync: {
                     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 content: import("valibot").ObjectSchema<{
+                            readonly content: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+                                readonly type: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            }, undefined>, undefined>;
+                            readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"doc", undefined>], undefined>;
+                        }, undefined>;
                         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>;
@@ -327,7 +337,12 @@ export declare const sync: {
                         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 content: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                                readonly content: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+                                    readonly type: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                }, undefined>, undefined>;
+                                readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"doc", undefined>], undefined>;
+                            }, undefined>, 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>;
@@ -335,44 +350,79 @@ export declare const sync: {
                         readonly '~standard': import("valibot").StandardSchemaProps<{
                             bcc?: string[] | undefined;
                             cc?: string[] | undefined;
+                            content?: {
+                                type: "doc";
+                                content: ({
+                                    type: string;
+                                } & {
+                                    [key: string]: unknown;
+                                })[];
+                            } | undefined;
                             replyTo?: string[] | undefined;
                             to?: string[] | undefined;
-                            content?: unknown;
                             subject?: string | undefined;
                         }, {
                             bcc?: string[] | undefined;
                             cc?: string[] | undefined;
+                            content?: {
+                                type: "doc";
+                                content: ({
+                                    type: string;
+                                } & {
+                                    [key: string]: unknown;
+                                })[];
+                            } | 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;
+                            content?: {
+                                type: "doc";
+                                content: ({
+                                    type: string;
+                                } & {
+                                    [key: string]: unknown;
+                                })[];
+                            } | 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>;
+                        }, import("valibot").LiteralIssue | import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").UnionIssue<import("valibot").LiteralIssue> | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue | import("valibot").LooseObjectIssue>;
                         readonly '~types'?: {
                             readonly input: {
                                 bcc?: string[] | undefined;
                                 cc?: string[] | undefined;
+                                content?: {
+                                    type: "doc";
+                                    content: ({
+                                        type: string;
+                                    } & {
+                                        [key: string]: unknown;
+                                    })[];
+                                } | undefined;
                                 replyTo?: string[] | undefined;
                                 to?: string[] | undefined;
-                                content?: unknown;
                                 subject?: string | undefined;
                             };
                             readonly output: {
                                 bcc?: string[] | undefined;
                                 cc?: string[] | undefined;
+                                content?: {
+                                    type: "doc";
+                                    content: ({
+                                        type: string;
+                                    } & {
+                                        [key: string]: unknown;
+                                    })[];
+                                } | 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;
+                            readonly issue: import("valibot").LiteralIssue | import("valibot").StringIssue | import("valibot").EmailIssue<string> | import("valibot").MaxLengthIssue<string, 255> | import("valibot").NonEmptyIssue<string> | import("valibot").ObjectIssue | import("valibot").UnionIssue<import("valibot").LiteralIssue> | import("valibot").NonOptionalIssue | import("valibot").ArrayIssue | import("valibot").LooseObjectIssue;
                         } | 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>;
@@ -385,7 +435,12 @@ export declare const sync: {
                     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 content: import("valibot").ObjectSchema<{
+                            readonly content: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+                                readonly type: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            }, undefined>, undefined>;
+                            readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"doc", undefined>], undefined>;
+                        }, undefined>;
                         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>;

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

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

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

@@ -24,7 +24,12 @@ export declare const syncPullDraft: import("../../../../..").EndpointConfig<"/v1
                 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 content: v.ObjectSchema<{
+                        readonly content: v.ArraySchema<v.LooseObjectSchema<{
+                            readonly type: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        }, undefined>, undefined>;
+                        readonly type: v.UnionSchema<[v.LiteralSchema<"doc", undefined>], undefined>;
+                    }, undefined>;
                     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>;

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

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

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

@@ -104,7 +104,12 @@ export declare const pull: {
                     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 content: import("valibot").ObjectSchema<{
+                            readonly content: import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+                                readonly type: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            }, undefined>, undefined>;
+                            readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"doc", undefined>], undefined>;
+                        }, undefined>;
                         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>;

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

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

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

@@ -13,7 +13,12 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
             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 content: v.ObjectSchema<{
+                    readonly content: v.ArraySchema<v.LooseObjectSchema<{
+                        readonly type: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly type: v.UnionSchema<[v.LiteralSchema<"doc", undefined>], undefined>;
+                }, undefined>;
                 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>;
@@ -21,7 +26,12 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
                 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 content: v.OptionalSchema<v.ObjectSchema<{
+                        readonly content: v.ArraySchema<v.LooseObjectSchema<{
+                            readonly type: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        }, undefined>, undefined>;
+                        readonly type: v.UnionSchema<[v.LiteralSchema<"doc", undefined>], undefined>;
+                    }, undefined>, 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>;
@@ -29,44 +39,79 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
                 readonly '~standard': v.StandardSchemaProps<{
                     bcc?: string[] | undefined;
                     cc?: string[] | undefined;
+                    content?: {
+                        type: "doc";
+                        content: ({
+                            type: string;
+                        } & {
+                            [key: string]: unknown;
+                        })[];
+                    } | undefined;
                     replyTo?: string[] | undefined;
                     to?: string[] | undefined;
-                    content?: unknown;
                     subject?: string | undefined;
                 }, {
                     bcc?: string[] | undefined;
                     cc?: string[] | undefined;
+                    content?: {
+                        type: "doc";
+                        content: ({
+                            type: string;
+                        } & {
+                            [key: string]: unknown;
+                        })[];
+                    } | 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;
+                    content?: {
+                        type: "doc";
+                        content: ({
+                            type: string;
+                        } & {
+                            [key: string]: unknown;
+                        })[];
+                    } | 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>;
+                }, v.LiteralIssue | v.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ObjectIssue | v.UnionIssue<v.LiteralIssue> | v.NonOptionalIssue | v.ArrayIssue | v.LooseObjectIssue>;
                 readonly '~types'?: {
                     readonly input: {
                         bcc?: string[] | undefined;
                         cc?: string[] | undefined;
+                        content?: {
+                            type: "doc";
+                            content: ({
+                                type: string;
+                            } & {
+                                [key: string]: unknown;
+                            })[];
+                        } | undefined;
                         replyTo?: string[] | undefined;
                         to?: string[] | undefined;
-                        content?: unknown;
                         subject?: string | undefined;
                     };
                     readonly output: {
                         bcc?: string[] | undefined;
                         cc?: string[] | undefined;
+                        content?: {
+                            type: "doc";
+                            content: ({
+                                type: string;
+                            } & {
+                                [key: string]: unknown;
+                            })[];
+                        } | 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;
+                    readonly issue: v.LiteralIssue | v.StringIssue | v.EmailIssue<string> | v.MaxLengthIssue<string, 255> | v.NonEmptyIssue<string> | v.ObjectIssue | v.UnionIssue<v.LiteralIssue> | v.NonOptionalIssue | v.ArrayIssue | v.LooseObjectIssue;
                 } | undefined;
             };
             readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
@@ -79,7 +124,12 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
             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 content: v.ObjectSchema<{
+                    readonly content: v.ArraySchema<v.LooseObjectSchema<{
+                        readonly type: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly type: v.UnionSchema<[v.LiteralSchema<"doc", undefined>], undefined>;
+                }, undefined>;
                 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>;

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

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