@marcoappio/marco-config 2.0.270 → 2.0.271

package/dist/clients/account.d.ts

@@ -2,10 +2,11 @@ import * as v from 'valibot';
 export declare const account: {
     model: v.ObjectSchema<{
         readonly connectionConfig: v.NullableSchema<v.ObjectSchema<{
-            readonly authType: v.UnionSchema<[v.LiteralSchema<"PASSWORD", undefined>, v.LiteralSchema<"GOOGLE_OAUTH", undefined>], undefined>;
             readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
             readonly smtpHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly smtpPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly smtpPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
         }, undefined>, undefined>;
         readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
@@ -42,7 +43,6 @@ export declare const account: {
         setConnectionConfig: {
             delta: v.ObjectSchema<{
                 readonly connectionConfig: v.ObjectSchema<{
-                    readonly authType: v.LiteralSchema<"PASSWORD", undefined>;
                     readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;

package/dist/clients/account.js

@@ -37,7 +37,7 @@ export const account = {
         },
         setConnectionConfig: {
             delta: v.object({
-                connectionConfig: marcoSchemas.emailAccount.fullConnectionConfig(),
+                connectionConfig: marcoSchemas.emailAccount.connectionConfig(),
                 id: marcoSchemas.string.shortUUID(),
             }),
         },

package/dist/clients/index.d.ts

@@ -3,10 +3,11 @@ export declare const marcoClients: {
     account: {
         model: import("valibot").ObjectSchema<{
             readonly connectionConfig: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
-                readonly authType: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"PASSWORD", undefined>, import("valibot").LiteralSchema<"GOOGLE_OAUTH", undefined>], undefined>;
                 readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                 readonly smtpHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly smtpPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly smtpPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
             }, undefined>, undefined>;
             readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
@@ -43,7 +44,6 @@ export declare const marcoClients: {
             setConnectionConfig: {
                 delta: import("valibot").ObjectSchema<{
                     readonly connectionConfig: import("valibot").ObjectSchema<{
-                        readonly authType: import("valibot").LiteralSchema<"PASSWORD", undefined>;
                         readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly imapPort: 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/marcoPublicConfig.d.ts

@@ -1,12 +1,6 @@
 export type MarcoEnvironment = 'production' | 'staging' | 'development';
 export declare const MARCO_ENV: MarcoEnvironment;
 type MarcoPublicConfig = {
-    google: {
-        oauth: {
-            clientId: string;
-            redirectUri: string;
-        };
-    };
     marco: {
         api: {
             baseUrl: string;

package/dist/marcoPublicConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"marcoPublicConfig.d.ts","sourceRoot":"","sources":["../src/marcoPublicConfig.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;AAEvE,eAAO,MAAM,SAAS,kBAA6D,CAAA;AAEnF,KAAK,iBAAiB,GAAG;IACvB,MAAM,EAAE;QACN,KAAK,EAAE;YACL,QAAQ,EAAE,MAAM,CAAA;YAChB,WAAW,EAAE,MAAM,CAAA;SACpB,CAAA;KACF,CAAA;IACD,KAAK,EAAE;QACL,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,EAAE,EAAE;YACF,KAAK,EAAE,MAAM,CAAA;YACb,IAAI,EAAE,MAAM,CAAA;YACZ,GAAG,EAAE,MAAM,CAAA;SACZ,CAAA;KACF,CAAA;IACD,UAAU,EAAE;QACV,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;IACD,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;CACF,CAAA;AAwFD,eAAO,MAAM,iBAAiB,mBAAuB,CAAA"}
+{"version":3,"file":"marcoPublicConfig.d.ts","sourceRoot":"","sources":["../src/marcoPublicConfig.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;AAEvE,eAAO,MAAM,SAAS,kBAA6D,CAAA;AAEnF,KAAK,iBAAiB,GAAG;IACvB,KAAK,EAAE;QACL,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,EAAE,EAAE;YACF,KAAK,EAAE,MAAM,CAAA;YACb,IAAI,EAAE,MAAM,CAAA;YACZ,GAAG,EAAE,MAAM,CAAA;SACZ,CAAA;KACF,CAAA;IACD,UAAU,EAAE;QACV,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;IACD,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;CACF,CAAA;AAsED,eAAO,MAAM,iBAAiB,mBAAuB,CAAA"}

package/dist/marcoPublicConfig.js

@@ -1,12 +1,6 @@
 export const MARCO_ENV = process.env.MARCO_ENV || 'development';
 const configMap = {
     development: {
-        google: {
-            oauth: {
-                clientId: '338197922176-oml1o2iputhhu3vijgue9h8sbfq17qme.apps.googleusercontent.com',
-                redirectUri: 'http://localhost:3000/oauth/google/callback',
-            },
-        },
         marco: {
             api: {
                 baseUrl: 'https://api.staging.marcoapp.io',
@@ -28,12 +22,6 @@ const configMap = {
         },
     },
     staging: {
-        google: {
-            oauth: {
-                clientId: '338197922176-oml1o2iputhhu3vijgue9h8sbfq17qme.apps.googleusercontent.com',
-                redirectUri: 'https://app.staging.marcoapp.io/oauth/google/callback',
-            },
-        },
         marco: {
             api: {
                 baseUrl: 'https://api.staging.marcoapp.io',
@@ -56,12 +44,6 @@ const configMap = {
     },
     // eslint-disable-next-line sort-keys, sort-keys-fix/sort-keys-fix
     production: {
-        google: {
-            oauth: {
-                clientId: '338197922176-oml1o2iputhhu3vijgue9h8sbfq17qme.apps.googleusercontent.com',
-                redirectUri: 'https://app.marcoapp.io/oauth/google/callback',
-            },
-        },
         marco: {
             api: {
                 baseUrl: 'https://api.marcoapp.io',

package/dist/schemas/index.d.ts

@@ -16,14 +16,6 @@ export declare const marcoSchemas: {
     };
     emailAccount: {
         connectionConfig: () => v.ObjectSchema<{
-            readonly authType: v.UnionSchema<[v.LiteralSchema<"PASSWORD", undefined>, v.LiteralSchema<"GOOGLE_OAUTH", undefined>], undefined>;
-            readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-            readonly smtpHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly smtpPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-        }, undefined>;
-        fullConnectionConfig: () => v.ObjectSchema<{
-            readonly authType: v.LiteralSchema<"PASSWORD", undefined>;
             readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAwCP,MAAM,OAAO,MAAM;;;;;;;;;;;;;CAMpC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAgCP,MAAM,OAAO,MAAM;;;;;;;;;;;;;CAMpC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA"}

package/dist/schemas/index.js

@@ -17,14 +17,6 @@ export const marcoSchemas = {
     },
     emailAccount: {
         connectionConfig: () => v.object({
-            authType: v.union([v.literal('PASSWORD'), v.literal('GOOGLE_OAUTH')]),
-            imapHost: marcoSchemas.string.required(),
-            imapPort: marcoSchemas.number.minMax(1, 65535),
-            smtpHost: marcoSchemas.string.required(),
-            smtpPort: marcoSchemas.number.minMax(1, 65535),
-        }),
-        fullConnectionConfig: () => v.object({
-            authType: v.literal('PASSWORD'),
             imapHost: marcoSchemas.string.required(),
             imapPassword: marcoSchemas.string.required(),
             imapPort: marcoSchemas.number.minMax(1, 65535),

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

@@ -2,33 +2,6 @@ import { GenericSchema } from 'valibot';
 import { EndpointConfig } from '../../types';
 export declare const endpoints: {
     private: {
-        emailAccount: {
-            oAuthGoogleConnect: EndpointConfig<"/v1/pv/account/:accountId/oauth/google/connect", import("valibot").ObjectSchema<{
-                readonly code: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<401, undefined>;
-            }, undefined>, import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
-                    readonly issues: import("valibot").ObjectSchema<{
-                        readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-                        readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                        readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                    }, undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<400, undefined>;
-            }, undefined>, import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>, import("valibot").ObjectSchema<{
-                readonly status: import("valibot").LiteralSchema<200, undefined>;
-            }, undefined>], undefined>>;
-        };
         emailMessage: {
             getAttachment: EndpointConfig<"/v1/pv/thread/:threadId/message/:messageId/attachment/:attachmentId", GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
@@ -61,6 +34,39 @@ export declare const endpoints: {
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
             }, undefined>], undefined>>;
         };
+        oauth: {
+            google: {
+                authorize: EndpointConfig<"/v1/pv/oauth/google/authorize", import("valibot").ObjectSchema<{
+                    readonly accountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly redirectTo: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
+                }, undefined>, GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<401, undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly issues: import("valibot").ObjectSchema<{
+                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                            readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<400, undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<404, undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly url: import("valibot").StringSchema<undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<200, undefined>;
+                }, undefined>], undefined>>;
+            };
+        };
         sync: {
             pull: {
                 account: EndpointConfig<"/v1/pv/sync/pull/account", import("valibot").ObjectSchema<{
@@ -95,10 +101,11 @@ export declare const endpoints: {
                             readonly op: import("valibot").LiteralSchema<"put", undefined>;
                             readonly value: import("valibot").ObjectSchema<{
                                 readonly connectionConfig: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
-                                    readonly authType: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"PASSWORD", undefined>, import("valibot").LiteralSchema<"GOOGLE_OAUTH", undefined>], undefined>;
                                     readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                                     readonly smtpHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    readonly smtpPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly smtpPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                                 }, undefined>, undefined>;
                                 readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
@@ -372,7 +379,6 @@ export declare const endpoints: {
                     }, undefined> | import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
                             readonly connectionConfig: import("valibot").ObjectSchema<{
-                                readonly authType: import("valibot").LiteralSchema<"PASSWORD", undefined>;
                                 readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;

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

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

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

@@ -1,31 +1,4 @@
 export declare const privateGroup: {
-    emailAccount: {
-        oAuthGoogleConnect: import("../../..").EndpointConfig<"/v1/pv/account/:accountId/oauth/google/connect", import("valibot").ObjectSchema<{
-            readonly code: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<401, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
-                readonly issues: import("valibot").ObjectSchema<{
-                    readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-                    readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                    readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                }, undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<400, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<404, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly status: import("valibot").LiteralSchema<200, undefined>;
-        }, undefined>], undefined>>;
-    };
     emailMessage: {
         getAttachment: import("../../..").EndpointConfig<"/v1/pv/thread/:threadId/message/:messageId/attachment/:attachmentId", 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 data: import("valibot").ObjectSchema<{
@@ -58,6 +31,39 @@ export declare const privateGroup: {
             readonly status: import("valibot").LiteralSchema<200, undefined>;
         }, undefined>], undefined>>;
     };
+    oauth: {
+        google: {
+            authorize: import("../../..").EndpointConfig<"/v1/pv/oauth/google/authorize", import("valibot").ObjectSchema<{
+                readonly accountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly redirectTo: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
+            }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                    readonly issues: import("valibot").ObjectSchema<{
+                        readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                        readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<400, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<404, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly url: import("valibot").StringSchema<undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>>;
+        };
+    };
     sync: {
         pull: {
             account: import("../../..").EndpointConfig<"/v1/pv/sync/pull/account", import("valibot").ObjectSchema<{
@@ -92,10 +98,11 @@ export declare const privateGroup: {
                         readonly op: import("valibot").LiteralSchema<"put", undefined>;
                         readonly value: import("valibot").ObjectSchema<{
                             readonly connectionConfig: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
-                                readonly authType: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"PASSWORD", undefined>, import("valibot").LiteralSchema<"GOOGLE_OAUTH", undefined>], undefined>;
                                 readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                                 readonly smtpHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly smtpPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly smtpPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                             }, undefined>, undefined>;
                             readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
@@ -369,7 +376,6 @@ export declare const privateGroup: {
                 }, undefined> | import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
                         readonly connectionConfig: import("valibot").ObjectSchema<{
-                            readonly authType: import("valibot").LiteralSchema<"PASSWORD", undefined>;
                             readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;

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

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

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

@@ -1,10 +1,10 @@
-import { emailAccount } from '../../../sdk/endpoints/private/emailAccount';
 import { emailMessage } from './emailMessage';
+import { oauth } from './oauth';
 import { sync } from './sync';
 import { user } from './user';
 export const privateGroup = {
-    emailAccount,
     emailMessage,
+    oauth,
     sync,
     user,
 };

package/dist/sdk/endpoints/private/{emailAccount/oauth-google-connect.d.ts → oauth/google/authorize.d.ts}

@@ -1,6 +1,7 @@
 import * as v from 'valibot';
-export declare const oAuthGoogleConnect: import("../../../..").EndpointConfig<"/v1/pv/account/:accountId/oauth/google/connect", v.ObjectSchema<{
-    readonly code: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+export declare const authorize: import("../../../../..").EndpointConfig<"/v1/pv/oauth/google/authorize", v.ObjectSchema<{
+    readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly redirectTo: v.SchemaWithPipe<[v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
@@ -22,6 +23,9 @@ export declare const oAuthGoogleConnect: import("../../../..").EndpointConfig<"/
     }, undefined>;
     readonly status: v.LiteralSchema<404, undefined>;
 }, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly url: v.StringSchema<undefined>;
+    }, undefined>;
     readonly status: v.LiteralSchema<200, undefined>;
 }, undefined>], undefined>>;
-//# sourceMappingURL=oauth-google-connect.d.ts.map
+//# sourceMappingURL=authorize.d.ts.map

package/dist/sdk/endpoints/private/oauth/google/authorize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/oauth/google/authorize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAkBpB,CAAA"}

package/dist/sdk/endpoints/private/oauth/google/authorize.js

@@ -0,0 +1,23 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../../../schemas';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { accountNotFoundErrorSchema, authFailedErrorSchema, validationFailedErrorSchema } from '../../../../../sdk/validation/errors';
+export const authorize = createEndpoint({
+    body: v.object({
+        accountId: marcoSchemas.string.required(),
+        redirectTo: v.pipe(v.string(), v.url()),
+    }),
+    method: 'POST',
+    path: '/v1/pv/oauth/google/authorize',
+    response: v.union([
+        authFailedErrorSchema,
+        validationFailedErrorSchema,
+        accountNotFoundErrorSchema,
+        v.object({
+            data: v.object({
+                url: v.string(),
+            }),
+            status: v.literal(200),
+        }),
+    ]),
+});

package/dist/sdk/endpoints/private/{emailAccount → oauth/google}/index.d.ts

@@ -1,6 +1,7 @@
-export declare const emailAccount: {
-    oAuthGoogleConnect: import("../../../..").EndpointConfig<"/v1/pv/account/:accountId/oauth/google/connect", import("valibot").ObjectSchema<{
-        readonly code: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+export declare const google: {
+    authorize: import("../../../../..").EndpointConfig<"/v1/pv/oauth/google/authorize", import("valibot").ObjectSchema<{
+        readonly accountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly redirectTo: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
         readonly data: import("valibot").ObjectSchema<{
             readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
@@ -22,6 +23,9 @@ export declare const emailAccount: {
         }, undefined>;
         readonly status: import("valibot").LiteralSchema<404, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly url: import("valibot").StringSchema<undefined>;
+        }, undefined>;
         readonly status: import("valibot").LiteralSchema<200, undefined>;
     }, undefined>], undefined>>;
 };

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

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

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

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

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

@@ -0,0 +1,34 @@
+export declare const oauth: {
+    google: {
+        authorize: import("../../../..").EndpointConfig<"/v1/pv/oauth/google/authorize", import("valibot").ObjectSchema<{
+            readonly accountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly redirectTo: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
+        }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<401, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                readonly issues: import("valibot").ObjectSchema<{
+                    readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                    readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                }, undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<400, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<404, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly url: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<200, undefined>;
+        }, undefined>], undefined>>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

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

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

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

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

@@ -32,10 +32,11 @@ export declare const sync: {
                     readonly op: import("valibot").LiteralSchema<"put", undefined>;
                     readonly value: import("valibot").ObjectSchema<{
                         readonly connectionConfig: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
-                            readonly authType: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"PASSWORD", undefined>, import("valibot").LiteralSchema<"GOOGLE_OAUTH", undefined>], undefined>;
                             readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                             readonly smtpHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly smtpPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly smtpPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                         }, undefined>, undefined>;
                         readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
@@ -309,7 +310,6 @@ export declare const sync: {
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly connectionConfig: import("valibot").ObjectSchema<{
-                        readonly authType: import("valibot").LiteralSchema<"PASSWORD", undefined>;
                         readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly imapPort: 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/pull/account.d.ts

@@ -31,10 +31,11 @@ export declare const syncPullAccount: import("../../../../..").EndpointConfig<"/
             readonly op: v.LiteralSchema<"put", undefined>;
             readonly value: v.ObjectSchema<{
                 readonly connectionConfig: v.NullableSchema<v.ObjectSchema<{
-                    readonly authType: v.UnionSchema<[v.LiteralSchema<"PASSWORD", undefined>, v.LiteralSchema<"GOOGLE_OAUTH", undefined>], undefined>;
                     readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
                     readonly smtpHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly smtpPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly smtpPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
                 }, undefined>, undefined>;
                 readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, 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;AAM5B,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/index.d.ts

@@ -31,10 +31,11 @@ export declare const pull: {
                 readonly op: import("valibot").LiteralSchema<"put", undefined>;
                 readonly value: import("valibot").ObjectSchema<{
                     readonly connectionConfig: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
-                        readonly authType: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"PASSWORD", undefined>, import("valibot").LiteralSchema<"GOOGLE_OAUTH", undefined>], undefined>;
                         readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                         readonly smtpHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly smtpPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly smtpPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                     }, undefined>, undefined>;
                     readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;

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

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

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

@@ -20,7 +20,6 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly connectionConfig: v.ObjectSchema<{
-                readonly authType: v.LiteralSchema<"PASSWORD", undefined>;
                 readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly imapPort: 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;AAM5B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAyC1B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAyC1B,CAAA"}

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

@@ -20,7 +20,6 @@ export declare const push: {
         }, undefined> | import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
                 readonly connectionConfig: import("valibot").ObjectSchema<{
-                    readonly authType: import("valibot").LiteralSchema<"PASSWORD", undefined>;
                     readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly imapPort: 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/push/index.d.ts.map

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

package/dist/sdk/index.d.ts

@@ -1,33 +1,6 @@
 export declare const marcoSDK: {
     endpoints: {
         private: {
-            emailAccount: {
-                oAuthGoogleConnect: import("..").EndpointConfig<"/v1/pv/account/:accountId/oauth/google/connect", import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
-                        readonly issues: import("valibot").ObjectSchema<{
-                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-                            readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                        }, undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<400, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<404, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly status: import("valibot").LiteralSchema<200, undefined>;
-                }, undefined>], undefined>>;
-            };
             emailMessage: {
                 getAttachment: import("..").EndpointConfig<"/v1/pv/thread/:threadId/message/:messageId/attachment/:attachmentId", 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 data: import("valibot").ObjectSchema<{
@@ -60,6 +33,39 @@ export declare const marcoSDK: {
                     readonly status: import("valibot").LiteralSchema<200, undefined>;
                 }, undefined>], undefined>>;
             };
+            oauth: {
+                google: {
+                    authorize: import("..").EndpointConfig<"/v1/pv/oauth/google/authorize", import("valibot").ObjectSchema<{
+                        readonly accountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly redirectTo: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
+                    }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<401, undefined>;
+                    }, undefined>, import("valibot").ObjectSchema<{
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<400, undefined>;
+                    }, undefined>, import("valibot").ObjectSchema<{
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<404, undefined>;
+                    }, undefined>, import("valibot").ObjectSchema<{
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly url: import("valibot").StringSchema<undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<200, undefined>;
+                    }, undefined>], undefined>>;
+                };
+            };
             sync: {
                 pull: {
                     account: import("..").EndpointConfig<"/v1/pv/sync/pull/account", import("valibot").ObjectSchema<{
@@ -94,10 +100,11 @@ export declare const marcoSDK: {
                                 readonly op: import("valibot").LiteralSchema<"put", undefined>;
                                 readonly value: import("valibot").ObjectSchema<{
                                     readonly connectionConfig: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
-                                        readonly authType: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"PASSWORD", undefined>, import("valibot").LiteralSchema<"GOOGLE_OAUTH", undefined>], undefined>;
                                         readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                        readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                         readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                                         readonly smtpHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                        readonly smtpPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                         readonly smtpPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
                                     }, undefined>, undefined>;
                                     readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
@@ -371,7 +378,6 @@ export declare const marcoSDK: {
                         }, undefined> | import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
                                 readonly connectionConfig: import("valibot").ObjectSchema<{
-                                    readonly authType: import("valibot").LiteralSchema<"PASSWORD", undefined>;
                                     readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly imapPort: 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@marcoappio/marco-config",
   "packageManager": "bun@1.2.0",
-  "version": "2.0.270",
+  "version": "2.0.271",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",

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

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

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

@@ -1,4 +0,0 @@
-import { oAuthGoogleConnect } from '../../../../sdk/endpoints/private/emailAccount/oauth-google-connect';
-export const emailAccount = {
-    oAuthGoogleConnect: oAuthGoogleConnect,
-};

package/dist/sdk/endpoints/private/emailAccount/oauth-google-connect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"oauth-google-connect.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/emailAccount/oauth-google-connect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;2BAc7B,CAAA"}

package/dist/sdk/endpoints/private/emailAccount/oauth-google-connect.js

@@ -1,19 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../schemas';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { accountNotFoundErrorSchema, authFailedErrorSchema, validationFailedErrorSchema } from '../../../../sdk/validation/errors';
-export const oAuthGoogleConnect = createEndpoint({
-    body: v.object({
-        code: marcoSchemas.string.required(),
-    }),
-    method: 'POST',
-    path: '/v1/pv/account/:accountId/oauth/google/connect',
-    response: v.union([
-        authFailedErrorSchema,
-        validationFailedErrorSchema,
-        accountNotFoundErrorSchema,
-        v.object({
-            status: v.literal(200),
-        }),
-    ]),
-});