@marcoappio/marco-config 2.0.126 → 2.0.128

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

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const syncPullAccount: import("../../../../../types").EndpointConfig<"/v1/pv/sync/pull/account", v.ObjectSchema<{
+export declare const syncPullAccount: import("../../../../..").EndpointConfig<"/v1/pv/sync/pull/account", v.ObjectSchema<{
     readonly clientGroupID: v.StringSchema<undefined>;
     readonly cookie: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
@@ -27,13 +27,13 @@ export declare const syncPullAccount: import("../../../../../types").EndpointCon
                     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 import("../../../../../types").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 import("../../../../../types").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>;
         }, undefined>], undefined>, undefined>;

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

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

package/dist/sdk/endpoints/private/sync/pull/account.js

@@ -2,13 +2,12 @@ import * as v from 'valibot';
 import { account } from '../../../../../clients/account';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
 import { errorManifest } from '../../../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../../../types';
 export const syncPullAccount = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
         cookie: v.nullable(v.number()),
     }),
-    method: HTTPMethod.POST,
+    method: 'POST',
     path: account.pullURL,
     response: v.union([
         errorManifest.validationFailedErrorSchema,

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

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const syncPullContact: import("../../../../../types").EndpointConfig<"/v1/pv/sync/pull/contact", v.ObjectSchema<{
+export declare const syncPullContact: import("../../../../..").EndpointConfig<"/v1/pv/sync/pull/contact", v.ObjectSchema<{
     readonly clientGroupID: v.StringSchema<undefined>;
     readonly cookie: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{

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

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

package/dist/sdk/endpoints/private/sync/pull/contact.js

@@ -2,13 +2,12 @@ import * as v from 'valibot';
 import { contact } from '../../../../../clients/contact';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
 import { errorManifest } from '../../../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../../../types';
 export const syncPullContact = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
         cookie: v.nullable(v.number()),
     }),
-    method: HTTPMethod.POST,
+    method: 'POST',
     path: contact.pullURL,
     response: v.union([
         errorManifest.validationFailedErrorSchema,

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

@@ -27,13 +27,13 @@ export declare const pull: {
                         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>;
@@ -102,18 +102,33 @@ export declare const pull: {
                     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>;

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

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

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

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const syncPullThread: import("../../../../../types").EndpointConfig<"/v1/pv/sync/pull/thread", v.ObjectSchema<{
+export declare const syncPullThread: import("../../../../..").EndpointConfig<"/v1/pv/sync/pull/thread", v.ObjectSchema<{
     readonly clientGroupID: v.StringSchema<undefined>;
     readonly cookie: v.NullableSchema<v.ObjectSchema<{
         readonly id: v.StringSchema<undefined>;
@@ -31,18 +31,33 @@ export declare const syncPullThread: import("../../../../../types").EndpointConf
                 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 import("../../../../../types").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>;
         }, undefined>], undefined>, undefined>;

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

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

package/dist/sdk/endpoints/private/sync/pull/thread.js

@@ -2,7 +2,6 @@ import * as v from 'valibot';
 import { thread } from '../../../../../clients/thread';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
 import { errorManifest } from '../../../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../../../types';
 export const syncPullThread = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
@@ -11,7 +10,7 @@ export const syncPullThread = createEndpoint({
             version: v.number(),
         })),
     }),
-    method: HTTPMethod.POST,
+    method: 'POST',
     path: thread.pullURL,
     response: v.union([
         errorManifest.validationFailedErrorSchema,

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

@@ -1,11 +1,11 @@
 import * as v from 'valibot';
-export declare const syncPushAccount: import("../../../../../types").EndpointConfig<"/v1/pv/sync/push/account", v.ObjectSchema<{
+export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/v1/pv/sync/push/account", v.ObjectSchema<{
     readonly clientGroupID: v.StringSchema<undefined>;
     readonly mutations: v.ArraySchema<v.UnionSchema<[v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly imapPasswordConfig: v.ObjectSchema<{
-                readonly status: v.LiteralSchema<import("../../../../../types").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/sdk/endpoints/private/sync/push/account.d.ts.map

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

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

@@ -2,7 +2,6 @@ import * as v from 'valibot';
 import { account } from '../../../../../clients/account';
 import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
 import { errorManifest } from '../../../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../../../types';
 export const syncPushAccount = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
@@ -21,7 +20,7 @@ export const syncPushAccount = createEndpoint({
             }),
         ])),
     }),
-    method: HTTPMethod.POST,
+    method: 'POST',
     path: account.pushURL,
     response: v.union([
         errorManifest.validationFailedErrorSchema,

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

@@ -5,7 +5,7 @@ export declare const push: {
             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/user/deleteUser.d.ts

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const deleteUser: import("../../../../types").EndpointConfig<"/v1/pv/user", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
+export declare const deleteUser: import("../../../..").EndpointConfig<"/v1/pv/user", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
     readonly code: v.LiteralSchema<"NOT_AUTHENTICATED", undefined>;
     readonly status: v.LiteralSchema<401, undefined>;
 }, undefined>, v.ObjectSchema<{

package/dist/sdk/endpoints/private/user/deleteUser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deleteUser.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/user/deleteUser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,UAAU;;;;;2BASrB,CAAA"}
+{"version":3,"file":"deleteUser.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/user/deleteUser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,UAAU;;;;;2BASrB,CAAA"}

package/dist/sdk/endpoints/private/user/deleteUser.js

@@ -1,9 +1,8 @@
 import * as v from 'valibot';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
 import { notAuthenticatedErrorSchema } from '../../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../../types';
 export const deleteUser = createEndpoint({
-    method: HTTPMethod.DELETE,
+    method: 'DELETE',
     path: '/v1/pv/user',
     response: v.union([
         notAuthenticatedErrorSchema,

package/dist/sdk/endpoints/public/auth/refreshAuth.d.ts

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const refreshAuth: import("../../../../types/Endpoint").EndpointConfig<"/v1/pb/auth/refresh", v.ObjectSchema<{
+export declare const refreshAuth: import("../../../..").EndpointConfig<"/v1/pb/auth/refresh", v.ObjectSchema<{
     readonly refreshToken: v.StringSchema<undefined>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
     readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;

package/dist/sdk/endpoints/public/auth/refreshAuth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refreshAuth.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/refreshAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;2BAmBtB,CAAA"}
+{"version":3,"file":"refreshAuth.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/refreshAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;2BAmBtB,CAAA"}

package/dist/sdk/endpoints/public/auth/refreshAuth.js

@@ -1,12 +1,11 @@
 import * as v from 'valibot';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
 import { errorManifest } from '../../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../../types/Endpoint';
 export const refreshAuth = createEndpoint({
     body: v.object({
         refreshToken: v.string(),
     }),
-    method: HTTPMethod.POST,
+    method: 'POST',
     path: '/v1/pb/auth/refresh',
     response: v.union([
         errorManifest.validationFailedErrorSchema,

package/dist/sdk/endpoints/public/auth/sendAuthCode.d.ts

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const sendAuthCode: import("../../../../types/Endpoint").EndpointConfig<"/v1/pb/auth/send-code", v.ObjectSchema<{
+export declare const sendAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/send-code", v.ObjectSchema<{
     readonly email: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
     readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;

package/dist/sdk/endpoints/public/auth/sendAuthCode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sendAuthCode.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/sendAuthCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAO5B,eAAO,MAAM,YAAY;;;;;;;2BAYvB,CAAA"}
+{"version":3,"file":"sendAuthCode.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/sendAuthCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,YAAY;;;;;;;2BAYvB,CAAA"}

package/dist/sdk/endpoints/public/auth/sendAuthCode.js

@@ -2,12 +2,11 @@ import * as v from 'valibot';
 import { marcoSchemas } from '../../../../schemas';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
 import { errorManifest } from '../../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../../types/Endpoint';
 export const sendAuthCode = createEndpoint({
     body: v.object({
         email: marcoSchemas.string.email(),
     }),
-    method: HTTPMethod.POST,
+    method: 'POST',
     path: '/v1/pb/auth/send-code',
     response: v.union([
         errorManifest.validationFailedErrorSchema,

package/dist/sdk/endpoints/public/auth/verifyAuthCode.d.ts

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const verifyAuthCode: import("../../../../types/Endpoint").EndpointConfig<"/v1/pb/auth/verify-code", v.ObjectSchema<{
+export declare const verifyAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/verify-code", v.ObjectSchema<{
     readonly code: v.StringSchema<undefined>;
     readonly email: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{

package/dist/sdk/endpoints/public/auth/verifyAuthCode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verifyAuthCode.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/verifyAuthCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAO5B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;2BAoBzB,CAAA"}
+{"version":3,"file":"verifyAuthCode.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/verifyAuthCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;2BAoBzB,CAAA"}

package/dist/sdk/endpoints/public/auth/verifyAuthCode.js

@@ -2,13 +2,12 @@ import * as v from 'valibot';
 import { marcoSchemas } from '../../../../schemas';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
 import { errorManifest } from '../../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../../types/Endpoint';
 export const verifyAuthCode = createEndpoint({
     body: v.object({
         code: v.string(),
         email: marcoSchemas.string.email(),
     }),
-    method: HTTPMethod.POST,
+    method: 'POST',
     path: '/v1/pb/auth/verify-code',
     response: v.union([
         errorManifest.validationFailedErrorSchema,

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

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const healthcheck: import("../../../../types").EndpointConfig<"/v1/pb/healthcheck", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.ObjectSchema<{
+export declare const healthcheck: import("../../../..").EndpointConfig<"/v1/pb/healthcheck", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly status: v.LiteralSchema<"ok", undefined>;
     }, undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/healthcheck/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,WAAW;;;;;cAOtB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/healthcheck/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,eAAO,MAAM,WAAW;;;;;cAOtB,CAAA"}

package/dist/sdk/endpoints/public/healthcheck/index.js

@@ -1,8 +1,7 @@
 import * as v from 'valibot';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { HTTPMethod } from '../../../../types';
 export const healthcheck = createEndpoint({
-    method: HTTPMethod.GET,
+    method: 'GET',
     path: '/v1/pb/healthcheck',
     response: v.object({
         data: v.object({ status: v.literal('ok') }),

package/dist/sdk/index.d.ts

@@ -31,13 +31,13 @@ export declare const marcoSDK: {
                                         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>;
@@ -106,18 +106,33 @@ export declare const marcoSDK: {
                                     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>;
@@ -132,7 +147,7 @@ export declare const marcoSDK: {
                             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/index.d.ts.map

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

package/dist/types/Endpoint.d.ts

@@ -6,13 +6,7 @@ type URLParams<Segments extends readonly string[]> = {
 export type HTTPErrorStatusCode = 400 | 401 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
 export type HTTPSuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
 export type URLPattern<T extends string> = URLParams<Split<T>>;
-export declare enum HTTPMethod {
-    DELETE = "delete",
-    GET = "get",
-    PATCH = "patch",
-    POST = "post",
-    PUT = "put"
-}
+export type HTTPMethod = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
 export type EndpointError = {
     code: string;
     details?: any;

package/dist/types/Endpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Endpoint.d.ts","sourceRoot":"","sources":["../../src/types/Endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,MAAM,CAAC,EAAE,GAC5D,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,GAChB,CAAC,CAAC,CAAC,CAAA;AAEP,KAAK,SAAS,CAAC,QAAQ,SAAS,SAAS,MAAM,EAAE,IAAI;KAClD,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,GAAG,SAAS,IAAI,MAAM,KAAK,EAAE,GACrD,KAAK,GACL,KAAK,GAAG,MAAM;CACnB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAC3B,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,CAAA;AAEP,MAAM,MAAM,qBAAqB,GAC7B,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,CAAA;AAEP,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;AAE9D,oBAAY,UAAU;IACpB,MAAM,WAAW;IACjB,GAAG,QAAQ;IACX,KAAK,UAAU;IACf,IAAI,SAAS;IACb,GAAG,QAAQ;CACZ;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,GAAG,CAAA;IACb,MAAM,EAAE,mBAAmB,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,CAAC,EAAE,GAAG,CAAA;IACV,MAAM,EAAE,qBAAqB,CAAA;CAC9B,GAAG,aAAa,CAAA;AAEjB,MAAM,MAAM,cAAc,CACxB,KAAK,SAAS,MAAM,EACpB,YAAY,SAAS,aAAa,GAAG,SAAS,EAC9C,aAAa,SAAS,aAAa,GAAG,SAAS,EAC/C,SAAS,SAAS,aAAa,CAAC,gBAAgB,CAAC,IAC/C;IACF,IAAI,EAAE,YAAY,CAAA;IAClB,SAAS,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,KAAK,MAAM,CAAA;IAChD,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,KAAK,CAAA;IACX,KAAK,EAAE,aAAa,CAAA;IACpB,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA"}
+{"version":3,"file":"Endpoint.d.ts","sourceRoot":"","sources":["../../src/types/Endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,MAAM,CAAC,EAAE,GAC5D,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,GAChB,CAAC,CAAC,CAAC,CAAA;AAEP,KAAK,SAAS,CAAC,QAAQ,SAAS,SAAS,MAAM,EAAE,IAAI;KAClD,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,GAAG,SAAS,IAAI,MAAM,KAAK,EAAE,GACrD,KAAK,GACL,KAAK,GAAG,MAAM;CACnB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAC3B,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,CAAA;AAEP,MAAM,MAAM,qBAAqB,GAC7B,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,CAAA;AAEP,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;AAE9D,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAA;AAEpE,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,GAAG,CAAA;IACb,MAAM,EAAE,mBAAmB,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,CAAC,EAAE,GAAG,CAAA;IACV,MAAM,EAAE,qBAAqB,CAAA;CAC9B,GAAG,aAAa,CAAA;AAEjB,MAAM,MAAM,cAAc,CACxB,KAAK,SAAS,MAAM,EACpB,YAAY,SAAS,aAAa,GAAG,SAAS,EAC9C,aAAa,SAAS,aAAa,GAAG,SAAS,EAC/C,SAAS,SAAS,aAAa,CAAC,gBAAgB,CAAC,IAC/C;IACF,IAAI,EAAE,YAAY,CAAA;IAClB,SAAS,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,KAAK,MAAM,CAAA;IAChD,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,KAAK,CAAA;IACX,KAAK,EAAE,aAAa,CAAA;IACpB,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA"}

package/dist/types/Endpoint.js

@@ -1,8 +1 @@
-export var HTTPMethod;
-(function (HTTPMethod) {
-    HTTPMethod["DELETE"] = "delete";
-    HTTPMethod["GET"] = "get";
-    HTTPMethod["PATCH"] = "patch";
-    HTTPMethod["POST"] = "post";
-    HTTPMethod["PUT"] = "put";
-})(HTTPMethod || (HTTPMethod = {}));
+export {};

package/dist/types/MarcoClient.d.ts

@@ -1,4 +1,5 @@
 import * as v from 'valibot';
+import { marcoSchemas } from '../schemas';
 export type MarcoClient = {
     model: v.ObjectSchema<any, any>;
     mutators: Record<string, {
@@ -9,4 +10,5 @@ export type MarcoClient = {
     pushURL: string | null;
     schemaVersion: string;
 };
+export type LabelSpecialUse = v.InferOutput<ReturnType<typeof marcoSchemas.labelSpecialUse>>;
 //# sourceMappingURL=MarcoClient.d.ts.map

package/dist/types/MarcoClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarcoClient.d.ts","sourceRoot":"","sources":["../../src/types/MarcoClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IAC/B,QAAQ,EAAE,MAAM,CACd,MAAM,EACN;QACE,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;KAChC,CACF,CAAA;IACD,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA"}
+{"version":3,"file":"MarcoClient.d.ts","sourceRoot":"","sources":["../../src/types/MarcoClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IAC/B,QAAQ,EAAE,MAAM,CACd,MAAM,EACN;QACE,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;KAChC,CACF,CAAA;IACD,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA"}

package/dist/types/WS.d.ts

@@ -1,10 +1,7 @@
 import { marcoClients } from '../clients';
-export declare enum MarcoWSEventType {
-    SYNC_POKE = "SYNC_POKE"
-}
 export type MarcoWSSyncPoke = {
     data: keyof typeof marcoClients;
-    event: MarcoWSEventType.SYNC_POKE;
+    event: 'SYNC_POKE';
 };
 export type MarcoWSEvent = MarcoWSSyncPoke;
 //# sourceMappingURL=WS.d.ts.map

package/dist/types/WS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WS.d.ts","sourceRoot":"","sources":["../../src/types/WS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD,oBAAY,gBAAgB;IAC1B,SAAS,cAAc;CACxB;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,OAAO,YAAY,CAAA;IAC/B,KAAK,EAAE,gBAAgB,CAAC,SAAS,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,eAAe,CAAA"}
+{"version":3,"file":"WS.d.ts","sourceRoot":"","sources":["../../src/types/WS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,OAAO,YAAY,CAAA;IAC/B,KAAK,EAAE,WAAW,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,eAAe,CAAA"}

package/dist/types/WS.js

@@ -1,4 +1 @@
-export var MarcoWSEventType;
-(function (MarcoWSEventType) {
-    MarcoWSEventType["SYNC_POKE"] = "SYNC_POKE";
-})(MarcoWSEventType || (MarcoWSEventType = {}));
+export {};