@marcoappio/marco-config 2.0.125 → 2.0.127

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"}

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

@@ -0,0 +1,8 @@
+import * as v from 'valibot';
+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<{
+    readonly status: v.LiteralSchema<204, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=deleteUser.d.ts.map

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

@@ -0,0 +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;AAK5B,eAAO,MAAM,UAAU;;;;;2BASrB,CAAA"}

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

@@ -0,0 +1,13 @@
+import * as v from 'valibot';
+import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
+import { notAuthenticatedErrorSchema } from '../../../../sdk/validation/errors';
+export const deleteUser = createEndpoint({
+    method: 'DELETE',
+    path: '/v1/pv/user',
+    response: v.union([
+        notAuthenticatedErrorSchema,
+        v.object({
+            status: v.literal(204),
+        }),
+    ]),
+});

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

@@ -0,0 +1,9 @@
+export declare const user: {
+    deleteUser: import("../../../..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly code: import("valibot").LiteralSchema<"NOT_AUTHENTICATED", undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly status: import("valibot").LiteralSchema<204, undefined>;
+    }, undefined>], undefined>>;
+};
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,4 @@
+import { deleteUser } from './deleteUser';
+export const user = {
+    deleteUser,
+};

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') }),