@marcoappio/marco-config 2.0.126 → 2.0.128

package/dist/clients/account.d.ts

@@ -1,5 +1,4 @@
 import * as v from 'valibot';
-import { IMAPPasswordConfigStatus, LabelSpecialUse } from '../types';
 export declare const account: {
     model: v.ObjectSchema<{
         readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
@@ -8,13 +7,13 @@ export declare const account: {
             readonly host: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly password: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly port: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-            readonly status: v.EnumSchema<typeof IMAPPasswordConfigStatus, undefined>;
+            readonly status: v.UnionSchema<[v.LiteralSchema<"AWAITING_CONNECTION", undefined>, v.LiteralSchema<"CONNECTED", undefined>, v.LiteralSchema<"CONNECTION_FAILED", undefined>], undefined>;
         }, undefined>, undefined>;
         readonly labels: v.ArraySchema<v.ObjectSchema<{
             readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly name: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly path: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-            readonly specialUse: v.NullableSchema<v.EnumSchema<typeof LabelSpecialUse, undefined>, undefined>;
+            readonly specialUse: v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"ARCHIVE", undefined>, v.LiteralSchema<"INBOX", undefined>, v.LiteralSchema<"SENT", undefined>, v.LiteralSchema<"SPAM", undefined>, v.LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
         }, undefined>, undefined>;
     }, undefined>;
     mutators: {
@@ -27,7 +26,7 @@ export declare const account: {
             delta: v.ObjectSchema<{
                 readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly imapPasswordConfig: v.ObjectSchema<{
-                    readonly status: v.LiteralSchema<IMAPPasswordConfigStatus.AWAITING_CONNECTION, undefined>;
+                    readonly status: v.LiteralSchema<"AWAITING_CONNECTION", undefined>;
                     readonly host: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly password: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly port: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/clients/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAe,MAAM,qBAAqB,CAAA;AAS5F,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCG,CAAA"}
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/clients/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAY5B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCG,CAAA"}

package/dist/clients/account.js

@@ -1,11 +1,10 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../schemas';
-import { IMAPPasswordConfigStatus, LabelSpecialUse } from '../types';
 const imapPasswordConfig = v.object({
     host: marcoSchemas.string.required(),
     password: marcoSchemas.string.required(),
     port: marcoSchemas.number.minMax(1, 65535),
-    status: v.enum(IMAPPasswordConfigStatus),
+    status: marcoSchemas.emailAccountConnectionState(),
 });
 export const account = {
     model: v.object({
@@ -16,7 +15,7 @@ export const account = {
             id: marcoSchemas.string.required(),
             name: marcoSchemas.string.required(),
             path: marcoSchemas.string.required(),
-            specialUse: v.nullable(v.enum(LabelSpecialUse)),
+            specialUse: v.nullable(marcoSchemas.labelSpecialUse()),
         })),
     }),
     mutators: {
@@ -30,7 +29,7 @@ export const account = {
                 id: marcoSchemas.string.required(),
                 imapPasswordConfig: v.object({
                     ...imapPasswordConfig.entries,
-                    status: v.literal(IMAPPasswordConfigStatus.AWAITING_CONNECTION),
+                    status: v.literal('AWAITING_CONNECTION'),
                 }),
             }),
         },

package/dist/clients/index.d.ts

@@ -8,13 +8,13 @@ export declare const marcoClients: {
                 readonly host: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly password: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly port: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-                readonly status: import("valibot").EnumSchema<typeof import("../types").IMAPPasswordConfigStatus, undefined>;
+                readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED", undefined>], undefined>;
             }, undefined>, undefined>;
             readonly labels: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-                readonly specialUse: import("valibot").NullableSchema<import("valibot").EnumSchema<typeof import("../types").LabelSpecialUse, undefined>, undefined>;
+                readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>;
         mutators: {
@@ -27,7 +27,7 @@ export declare const marcoClients: {
                 delta: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly imapPasswordConfig: import("valibot").ObjectSchema<{
-                        readonly status: import("valibot").LiteralSchema<import("../types").IMAPPasswordConfigStatus.AWAITING_CONNECTION, undefined>;
+                        readonly status: import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>;
                         readonly host: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly password: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly port: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
@@ -57,18 +57,33 @@ export declare const marcoClients: {
             readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly messages: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-                readonly contacts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-                    readonly associationType: import("valibot").EnumSchema<typeof import("../types").ContactAssociationType, undefined>;
+                readonly bcc: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>, undefined>;
+                readonly cc: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                     readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 }, undefined>, undefined>;
                 readonly envelopeDate: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                 readonly envelopeSubject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly flagged: import("valibot").BooleanSchema<undefined>;
+                readonly from: import("valibot").ObjectSchema<{
+                    readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>;
                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly labelIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                 readonly previewText: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly replyTo: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>, undefined>;
                 readonly seen: import("valibot").BooleanSchema<undefined>;
+                readonly to: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>;
         mutators: {

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

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

package/dist/clients/thread.d.ts

@@ -1,22 +1,36 @@
 import * as v from 'valibot';
-import { ContactAssociationType } from '../types';
 export declare const thread: {
     model: v.ObjectSchema<{
         readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
         readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
         readonly messages: v.ArraySchema<v.ObjectSchema<{
-            readonly contacts: v.ArraySchema<v.ObjectSchema<{
-                readonly associationType: v.EnumSchema<typeof ContactAssociationType, undefined>;
+            readonly bcc: v.ArraySchema<v.ObjectSchema<{
+                readonly emailAddresses: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>, undefined>;
+            readonly cc: v.ArraySchema<v.ObjectSchema<{
                 readonly emailAddresses: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                 readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             }, undefined>, undefined>;
             readonly envelopeDate: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
             readonly envelopeSubject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly flagged: v.BooleanSchema<undefined>;
+            readonly from: v.ObjectSchema<{
+                readonly emailAddresses: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>;
             readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly labelIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
             readonly previewText: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly replyTo: v.ArraySchema<v.ObjectSchema<{
+                readonly emailAddresses: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>, undefined>;
             readonly seen: v.BooleanSchema<undefined>;
+            readonly to: v.ArraySchema<v.ObjectSchema<{
+                readonly emailAddresses: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>, undefined>;
         }, undefined>, undefined>;
     }, undefined>;
     mutators: {

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

@@ -1 +1 @@
-{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../src/clients/thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B,OAAO,EAAE,sBAAsB,EAAe,MAAM,qBAAqB,CAAA;AAQzE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCI,CAAA"}
+{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../src/clients/thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCI,CAAA"}

package/dist/clients/thread.js

@@ -1,8 +1,6 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../schemas';
-import { ContactAssociationType } from '../types';
 const inlineContact = v.object({
-    associationType: v.enum(ContactAssociationType),
     emailAddresses: v.array(marcoSchemas.string.email()),
     name: marcoSchemas.string.nullable(),
 });
@@ -11,14 +9,18 @@ export const thread = {
         emailAccountId: marcoSchemas.string.required(),
         id: marcoSchemas.string.required(),
         messages: v.array(v.object({
-            contacts: v.array(inlineContact),
+            bcc: v.array(inlineContact),
+            cc: v.array(inlineContact),
             envelopeDate: marcoSchemas.number.positiveInteger(),
             envelopeSubject: marcoSchemas.string.required(),
             flagged: v.boolean(),
+            from: inlineContact,
             id: marcoSchemas.string.required(),
             labelIds: v.array(marcoSchemas.string.required()),
             previewText: marcoSchemas.string.required(),
+            replyTo: v.array(inlineContact),
             seen: v.boolean(),
+            to: v.array(inlineContact),
         })),
     }),
     mutators: {

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

@@ -1,4 +1,4 @@
 export declare const marcoClientsUtils: {
-    labelSpecialUseOrdering: import("../..").LabelSpecialUse[];
+    labelSpecialUseOrdering: ("ARCHIVE" | "INBOX" | "SENT" | "SPAM" | "TRASH")[];
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/clients/utils/labelSpecialUseOrdering.js

@@ -1,8 +1,7 @@
-import { LabelSpecialUse } from '../../types';
 export const labelSpecialUseOrdering = [
-    LabelSpecialUse.INBOX,
-    LabelSpecialUse.SENT,
-    LabelSpecialUse.SPAM,
-    LabelSpecialUse.ARCHIVE,
-    LabelSpecialUse.TRASH,
+    'INBOX',
+    'SENT',
+    'SPAM',
+    'ARCHIVE',
+    'TRASH',
 ];

package/dist/index.d.ts

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

package/dist/index.d.ts.map

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

package/dist/index.js

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

package/dist/schemas.d.ts

@@ -1,4 +1,6 @@
 export declare const marcoSchemas: {
+    emailAccountConnectionState: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED", undefined>], undefined>;
+    labelSpecialUse: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>;
     number: {
         minMax: (min: number, max: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
         positiveInteger: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;

package/dist/schemas.d.ts.map

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

package/dist/schemas.js

@@ -1,5 +1,17 @@
-import { email, enum as enumValidator, integer, maxLength, maxValue, minValue, nonEmpty, nonOptional, nullable, number, pipe, string, undefinedable, regex as v_regex } from 'valibot';
+import { email, enum as enumValidator, integer, literal, maxLength, maxValue, minValue, nonEmpty, nonOptional, nullable, number, pipe, string, undefinedable, union, regex as v_regex } from 'valibot';
 export const marcoSchemas = {
+    emailAccountConnectionState: () => union([
+        literal('AWAITING_CONNECTION'),
+        literal('CONNECTED'),
+        literal('CONNECTION_FAILED'),
+    ]),
+    labelSpecialUse: () => union([
+        literal('ARCHIVE'),
+        literal('INBOX'),
+        literal('SENT'),
+        literal('SPAM'),
+        literal('TRASH'),
+    ]),
     number: {
         minMax: (min, max) => nonOptional(pipe(number(), minValue(min), maxValue(max))),
         positiveInteger: () => nonOptional(pipe(number(), integer(), minValue(0))),

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

@@ -32,13 +32,13 @@ export declare const endpoints: {
                                     readonly host: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                     readonly password: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                     readonly port: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-                                    readonly status: import("valibot").EnumSchema<typeof import("../../types").IMAPPasswordConfigStatus, undefined>;
+                                    readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED", undefined>], undefined>;
                                 }, undefined>, undefined>;
                                 readonly labels: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                     readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                     readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-                                    readonly specialUse: import("valibot").NullableSchema<import("valibot").EnumSchema<typeof import("../../types").LabelSpecialUse, undefined>, undefined>;
+                                    readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
                                 }, undefined>, undefined>;
                             }, undefined>;
                         }, undefined>], undefined>, undefined>;
@@ -107,18 +107,33 @@ export declare const endpoints: {
                                 readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly messages: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-                                    readonly contacts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-                                        readonly associationType: import("valibot").EnumSchema<typeof import("../../types").ContactAssociationType, undefined>;
+                                    readonly bcc: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                        readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                    }, undefined>, undefined>;
+                                    readonly cc: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                         readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                     }, undefined>, undefined>;
                                     readonly envelopeDate: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                                     readonly envelopeSubject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                     readonly flagged: import("valibot").BooleanSchema<undefined>;
+                                    readonly from: import("valibot").ObjectSchema<{
+                                        readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                    }, undefined>;
                                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                     readonly labelIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                                     readonly previewText: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                    readonly replyTo: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                        readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                    }, undefined>, undefined>;
                                     readonly seen: import("valibot").BooleanSchema<undefined>;
+                                    readonly to: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                        readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                    }, undefined>, undefined>;
                                 }, undefined>, undefined>;
                             }, undefined>;
                         }, undefined>], undefined>, undefined>;
@@ -133,7 +148,7 @@ export declare const endpoints: {
                         readonly args: import("valibot").ObjectSchema<{
                             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly imapPasswordConfig: import("valibot").ObjectSchema<{
-                                readonly status: import("valibot").LiteralSchema<import("../../types").IMAPPasswordConfigStatus.AWAITING_CONNECTION, undefined>;
+                                readonly status: import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>;
                                 readonly host: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly password: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly port: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;

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

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

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

@@ -29,13 +29,13 @@ export declare const privateGroup: {
                                 readonly host: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly password: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly port: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-                                readonly status: import("valibot").EnumSchema<typeof import("../../..").IMAPPasswordConfigStatus, undefined>;
+                                readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED", undefined>], undefined>;
                             }, undefined>, undefined>;
                             readonly labels: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-                                readonly specialUse: import("valibot").NullableSchema<import("valibot").EnumSchema<typeof import("../../..").LabelSpecialUse, undefined>, undefined>;
+                                readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
                             }, undefined>, undefined>;
                         }, undefined>;
                     }, undefined>], undefined>, undefined>;
@@ -104,18 +104,33 @@ export declare const privateGroup: {
                             readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly messages: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-                                readonly contacts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-                                    readonly associationType: import("valibot").EnumSchema<typeof import("../../..").ContactAssociationType, undefined>;
+                                readonly bcc: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                    readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                }, undefined>, undefined>;
+                                readonly cc: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                     readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 }, undefined>, undefined>;
                                 readonly envelopeDate: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                                 readonly envelopeSubject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly flagged: import("valibot").BooleanSchema<undefined>;
+                                readonly from: import("valibot").ObjectSchema<{
+                                    readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                }, undefined>;
                                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly labelIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                                 readonly previewText: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                readonly replyTo: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                    readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                }, undefined>, undefined>;
                                 readonly seen: import("valibot").BooleanSchema<undefined>;
+                                readonly to: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                    readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                                }, undefined>, undefined>;
                             }, undefined>, undefined>;
                         }, undefined>;
                     }, undefined>], undefined>, undefined>;
@@ -130,7 +145,7 @@ export declare const privateGroup: {
                     readonly args: import("valibot").ObjectSchema<{
                         readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly imapPasswordConfig: import("valibot").ObjectSchema<{
-                            readonly status: import("valibot").LiteralSchema<import("../../..").IMAPPasswordConfigStatus.AWAITING_CONNECTION, undefined>;
+                            readonly status: import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>;
                             readonly host: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly password: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly port: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, 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":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sdk/endpoints/private/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxB,CAAA"}

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

@@ -28,13 +28,13 @@ export declare const sync: {
                             readonly host: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly password: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly port: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-                            readonly status: import("valibot").EnumSchema<typeof import("../../../..").IMAPPasswordConfigStatus, undefined>;
+                            readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED", undefined>], undefined>;
                         }, undefined>, undefined>;
                         readonly labels: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-                            readonly specialUse: import("valibot").NullableSchema<import("valibot").EnumSchema<typeof import("../../../..").LabelSpecialUse, undefined>, undefined>;
+                            readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
                         }, undefined>, undefined>;
                     }, undefined>;
                 }, undefined>], undefined>, undefined>;
@@ -103,18 +103,33 @@ export declare const sync: {
                         readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly messages: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-                            readonly contacts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-                                readonly associationType: import("valibot").EnumSchema<typeof import("../../../..").ContactAssociationType, undefined>;
+                            readonly bcc: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            }, undefined>, undefined>;
+                            readonly cc: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                 readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             }, undefined>, undefined>;
                             readonly envelopeDate: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                             readonly envelopeSubject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly flagged: import("valibot").BooleanSchema<undefined>;
+                            readonly from: import("valibot").ObjectSchema<{
+                                readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            }, undefined>;
                             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly labelIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                             readonly previewText: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            readonly replyTo: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            }, undefined>, undefined>;
                             readonly seen: import("valibot").BooleanSchema<undefined>;
+                            readonly to: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                                readonly emailAddresses: 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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                            }, undefined>, undefined>;
                         }, undefined>, undefined>;
                     }, undefined>;
                 }, undefined>], undefined>, undefined>;
@@ -129,7 +144,7 @@ export declare const sync: {
                 readonly args: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly imapPasswordConfig: import("valibot").ObjectSchema<{
-                        readonly status: import("valibot").LiteralSchema<import("../../../..").IMAPPasswordConfigStatus.AWAITING_CONNECTION, undefined>;
+                        readonly status: import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>;
                         readonly host: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly password: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly port: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, 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"}