npm - @marcoappio/marco-config - Versions diffs - 2.0.162 → 2.0.163 - Mend

@marcoappio/marco-config 2.0.162 → 2.0.163

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/dist/clients/draft.d.ts CHANGED Viewed

@@ -4,7 +4,12 @@ export declare const draft: {
         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>;
@@ -19,7 +24,12 @@ export declare const draft: {
                 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>;
@@ -39,7 +49,12 @@ export declare const draft: {
                 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>;
@@ -47,7 +62,12 @@ export declare const draft: {
                     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>;
@@ -55,44 +75,79 @@ export declare const draft: {
                     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>;

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

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

package/dist/clients/draft.js CHANGED Viewed

@@ -3,7 +3,14 @@ import { marcoSchemas } from '../schemas';
 const body = v.object({
     bcc: v.array(marcoSchemas.string.email()),
     cc: v.array(marcoSchemas.string.email()),
-    content: v.unknown(),
+    content: v.object({
+        content: v.array(v.looseObject({
+            type: marcoSchemas.string.required(),
+        })),
+        type: v.union([
+            v.literal('doc'),
+        ]),
+    }),
     replyTo: v.array(marcoSchemas.string.email()),
     subject: marcoSchemas.string.required(),
     to: v.array(marcoSchemas.string.email()),

package/dist/clients/index.d.ts CHANGED Viewed

@@ -116,7 +116,12 @@ export declare const marcoClients: {
             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>;
@@ -131,7 +136,12 @@ export declare const marcoClients: {
                     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>;
@@ -151,7 +161,12 @@ export declare const marcoClients: {
                     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>;
@@ -159,7 +174,12 @@ export declare const marcoClients: {
                         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>;
@@ -167,44 +187,79 @@ export declare const marcoClients: {
                         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>;

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

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

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

@@ -3,7 +3,7 @@ import { EndpointConfig } from '../../types';
 export declare const endpoints: {
     private: {
         emailMessage: {
-            htmlGet: EndpointConfig<"/v1/pv/message/:messageId/html", GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            getHTML: EndpointConfig<"/v1/pv/message/:messageId/html", GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, 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<{
@@ -123,7 +123,12 @@ export declare const endpoints: {
                                 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>;
@@ -337,7 +342,12 @@ export declare const endpoints: {
                             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>;
@@ -345,7 +355,12 @@ export declare const endpoints: {
                                 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>;
@@ -353,44 +368,79 @@ export declare const endpoints: {
                                 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>;
@@ -403,7 +453,12 @@ export declare const endpoints: {
                             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/index.d.ts.map CHANGED Viewed

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

package/dist/sdk/endpoints/private/{email-message/email-message-html-get.d.ts → emailMessage/getEmailMessageHTML.d.ts} RENAMED Viewed

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const emailMessageHtmlGet: import("../../../..").EndpointConfig<"/v1/pv/message/:messageId/html", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
+export declare const getEmailMessageHTML: import("../../../..").EndpointConfig<"/v1/pv/message/:messageId/html", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
     readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, v.ObjectSchema<{
@@ -11,4 +11,4 @@ export declare const emailMessageHtmlGet: import("../../../..").EndpointConfig<"
     }, undefined>;
     readonly status: v.LiteralSchema<200, undefined>;
 }, undefined>], undefined>>;
-//# sourceMappingURL=email-message-html-get.d.ts.map
+//# sourceMappingURL=getEmailMessageHTML.d.ts.map

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageHTML.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"getEmailMessageHTML.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/emailMessage/getEmailMessageHTML.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;2BAa9B,CAAA"}

package/dist/sdk/endpoints/private/{email-message/email-message-html-get.js → emailMessage/getEmailMessageHTML.js} RENAMED Viewed

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
 import { authenticationFailedErrorSchema, messageNotFoundErrorSchema } from '../../../../sdk/validation/errors';
-export const emailMessageHtmlGet = createEndpoint({
+export const getEmailMessageHTML = createEndpoint({
     method: 'GET',
     path: '/v1/pv/message/:messageId/html',
     response: v.union([

package/dist/sdk/endpoints/private/{email-message → emailMessage}/index.d.ts RENAMED Viewed

@@ -1,5 +1,5 @@
 export declare const 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<{

package/dist/sdk/endpoints/private/emailMessage/index.d.ts.map ADDED Viewed

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

package/dist/sdk/endpoints/private/emailMessage/index.js ADDED Viewed

@@ -0,0 +1,4 @@
+import { getEmailMessageHTML } from './getEmailMessageHTML';
+export const emailMessage = {
+    getHTML: getEmailMessageHTML,
+};