@marcoappio/marco-config 2.0.116 → 2.0.118

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

@@ -0,0 +1,34 @@
+import * as v from 'valibot';
+export declare const syncPushAccount: import("../../../../../types").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 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>;
+            }, undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"setIMAPPasswordConfig", undefined>;
+    }, undefined>, 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>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"delete", undefined>;
+    }, undefined>], undefined>, undefined>;
+}, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
+    readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly code: v.LiteralSchema<"NOT_AUTHENTICATED", undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=account.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,31 @@
+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(),
+        mutations: v.array(v.union([
+            v.object({
+                args: account.mutators.setIMAPPasswordConfig.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('setIMAPPasswordConfig'),
+            }),
+            v.object({
+                args: account.mutators.delete.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('delete'),
+            }),
+        ])),
+    }),
+    method: HTTPMethod.POST,
+    path: account.pushURL,
+    response: v.union([
+        errorManifest.validationFailedErrorSchema,
+        errorManifest.notAuthenticatedErrorSchema,
+        v.object({ status: v.literal(200) }),
+    ]),
+});

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

@@ -0,0 +1,35 @@
+export declare const push: {
+    syncPushAccount: import("../../../../..").EndpointConfig<"/v1/pv/sync/push/account", import("valibot").ObjectSchema<{
+        readonly clientGroupID: import("valibot").StringSchema<undefined>;
+        readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            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 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>;
+                }, undefined>;
+            }, undefined>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"setIMAPPasswordConfig", undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            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>;
+            }, undefined>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly status: import("valibot").LiteralSchema<400, undefined>;
+    }, undefined>, 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<200, undefined>;
+    }, undefined>], undefined>>;
+};
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,2 @@
+import { syncPushAccount } from './account';
+export const push = { syncPushAccount };

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

@@ -2,7 +2,7 @@ export declare const auth: {
     refreshAuth: import("../../../..").EndpointConfig<"/v1/pb/auth/refresh", import("valibot").ObjectSchema<{
         readonly refreshToken: import("valibot").StringSchema<undefined>;
     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly code: import("valibot").LiteralSchema<"::VALIDATION_FAILED", undefined>;
+        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
         readonly status: import("valibot").LiteralSchema<400, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly code: import("valibot").LiteralSchema<"VERIFY_AUTH_CODE::INVALID_CODE", undefined>;
@@ -22,7 +22,7 @@ export declare const auth: {
     sendAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/send-code", import("valibot").ObjectSchema<{
         readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly code: import("valibot").LiteralSchema<"::VALIDATION_FAILED", undefined>;
+        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
         readonly status: import("valibot").LiteralSchema<400, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly status: import("valibot").LiteralSchema<200, undefined>;
@@ -31,7 +31,7 @@ export declare const auth: {
         readonly code: import("valibot").StringSchema<undefined>;
         readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly code: import("valibot").LiteralSchema<"::VALIDATION_FAILED", undefined>;
+        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
         readonly status: import("valibot").LiteralSchema<400, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly code: import("valibot").LiteralSchema<"VERIFY_AUTH_CODE::INVALID_CODE", undefined>;

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

@@ -2,7 +2,7 @@ import * as v from 'valibot';
 export declare const refreshAuth: import("../../../../types/Endpoint").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>;
+    readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
     readonly status: v.LiteralSchema<400, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly code: v.LiteralSchema<"VERIFY_AUTH_CODE::INVALID_CODE", undefined>;

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

@@ -2,7 +2,7 @@ import * as v from 'valibot';
 export declare const sendAuthCode: import("../../../../types/Endpoint").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>;
+    readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
     readonly status: v.LiteralSchema<400, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;

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

@@ -3,7 +3,7 @@ export declare const verifyAuthCode: import("../../../../types/Endpoint").Endpoi
     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<{
-    readonly code: v.LiteralSchema<"::VALIDATION_FAILED", undefined>;
+    readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
     readonly status: v.LiteralSchema<400, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly code: v.LiteralSchema<"VERIFY_AUTH_CODE::INVALID_CODE", undefined>;

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

@@ -3,7 +3,7 @@ export declare const publicGroup: {
         refreshAuth: import("../../..").EndpointConfig<"/v1/pb/auth/refresh", import("valibot").ObjectSchema<{
             readonly refreshToken: import("valibot").StringSchema<undefined>;
         }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"::VALIDATION_FAILED", undefined>;
+            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
             readonly status: import("valibot").LiteralSchema<400, undefined>;
         }, undefined>, import("valibot").ObjectSchema<{
             readonly code: import("valibot").LiteralSchema<"VERIFY_AUTH_CODE::INVALID_CODE", undefined>;
@@ -23,7 +23,7 @@ export declare const publicGroup: {
         sendAuthCode: import("../../..").EndpointConfig<"/v1/pb/auth/send-code", import("valibot").ObjectSchema<{
             readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
         }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"::VALIDATION_FAILED", undefined>;
+            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
             readonly status: import("valibot").LiteralSchema<400, undefined>;
         }, undefined>, import("valibot").ObjectSchema<{
             readonly status: import("valibot").LiteralSchema<200, undefined>;
@@ -32,7 +32,7 @@ export declare const publicGroup: {
             readonly code: import("valibot").StringSchema<undefined>;
             readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
         }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"::VALIDATION_FAILED", undefined>;
+            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
             readonly status: import("valibot").LiteralSchema<400, undefined>;
         }, undefined>, import("valibot").ObjectSchema<{
             readonly code: import("valibot").LiteralSchema<"VERIFY_AUTH_CODE::INVALID_CODE", undefined>;

package/dist/sdk/index.d.ts

@@ -1,29 +1,83 @@
 export declare const marcoSDK: {
     endpoints: {
         private: {
-            emailMessage: {
-                getText: import("..").EndpointConfig<"/v1/pv/email-message/:messageId/text", 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<"::UNAUTHENTICATED", undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"GET_TEXT::MESSAGE_NOT_FOUND", undefined>;
-                    readonly status: import("valibot").LiteralSchema<404, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly hasMore: import("valibot").BooleanSchema<undefined>;
-                        readonly html: import("valibot").UndefinedableSchema<import("valibot").StringSchema<undefined>, undefined>;
-                        readonly text: import("valibot").UndefinedableSchema<import("valibot").StringSchema<undefined>, undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<200, undefined>;
-                }, undefined>], undefined>>;
-            };
-            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<"::UNAUTHENTICATED", undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly status: import("valibot").LiteralSchema<204, undefined>;
-                }, undefined>], undefined>>;
+            sync: {
+                pull: {
+                    syncPullAccount: import("..").EndpointConfig<"/v1/pv/sync/pull/account", import("valibot").ObjectSchema<{
+                        readonly clientGroupID: import("valibot").StringSchema<undefined>;
+                        readonly cookie: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly status: import("valibot").LiteralSchema<400, undefined>;
+                    }, undefined>, import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"NOT_AUTHENTICATED", undefined>;
+                        readonly status: import("valibot").LiteralSchema<401, undefined>;
+                    }, undefined>, import("valibot").ObjectSchema<{
+                        readonly data: import("valibot").ObjectSchema<{
+                            readonly cookie: import("valibot").NumberSchema<undefined>;
+                            readonly lastMutationIDChanges: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>, undefined>;
+                            readonly patch: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                                readonly key: import("valibot").StringSchema<undefined>;
+                                readonly op: import("valibot").LiteralSchema<"del", undefined>;
+                            }, undefined>, import("valibot").ObjectSchema<{
+                                readonly op: import("valibot").LiteralSchema<"clear", undefined>;
+                            }, undefined>, import("valibot").ObjectSchema<{
+                                readonly key: import("valibot").StringSchema<undefined>;
+                                readonly op: import("valibot").LiteralSchema<"put", undefined>;
+                                readonly value: import("valibot").ObjectSchema<{
+                                    readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<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 imapPasswordConfig: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                                        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>;
+                                    }, 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>;
+                                    }, undefined>, undefined>;
+                                }, undefined>;
+                            }, undefined>], undefined>, undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<200, undefined>;
+                    }, undefined>], undefined>>;
+                };
+                push: {
+                    syncPushAccount: import("..").EndpointConfig<"/v1/pv/sync/push/account", import("valibot").ObjectSchema<{
+                        readonly clientGroupID: import("valibot").StringSchema<undefined>;
+                        readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                            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 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>;
+                                }, undefined>;
+                            }, undefined>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"setIMAPPasswordConfig", undefined>;
+                        }, undefined>, import("valibot").ObjectSchema<{
+                            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>;
+                            }, undefined>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+                        }, undefined>], undefined>, undefined>;
+                    }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly status: import("valibot").LiteralSchema<400, undefined>;
+                    }, undefined>, 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<200, undefined>;
+                    }, undefined>], undefined>>;
+                };
             };
         };
         public: {
@@ -31,7 +85,7 @@ export declare const marcoSDK: {
                 refreshAuth: import("..").EndpointConfig<"/v1/pb/auth/refresh", import("valibot").ObjectSchema<{
                     readonly refreshToken: import("valibot").StringSchema<undefined>;
                 }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"::VALIDATION_FAILED", undefined>;
+                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                     readonly status: import("valibot").LiteralSchema<400, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"VERIFY_AUTH_CODE::INVALID_CODE", undefined>;
@@ -51,7 +105,7 @@ export declare const marcoSDK: {
                 sendAuthCode: import("..").EndpointConfig<"/v1/pb/auth/send-code", import("valibot").ObjectSchema<{
                     readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"::VALIDATION_FAILED", undefined>;
+                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                     readonly status: import("valibot").LiteralSchema<400, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly status: import("valibot").LiteralSchema<200, undefined>;
@@ -60,7 +114,7 @@ export declare const marcoSDK: {
                     readonly code: import("valibot").StringSchema<undefined>;
                     readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                 }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"::VALIDATION_FAILED", undefined>;
+                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                     readonly status: import("valibot").LiteralSchema<400, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"VERIFY_AUTH_CODE::INVALID_CODE", undefined>;
@@ -85,14 +139,6 @@ export declare const marcoSDK: {
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
             }, undefined>>;
         };
-        webhook: {
-            emailEngine: import("..").EndpointConfig<"/v1/wh/email-engine", 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<"::UNAUTHENTICATED", undefined>;
-                readonly status: import("valibot").LiteralSchema<401, undefined>;
-            }, undefined>, import("valibot").ObjectSchema<{
-                readonly status: import("valibot").LiteralSchema<200, undefined>;
-            }, undefined>], undefined>>;
-        };
     };
     validation: {
         utils: {

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

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

package/dist/sdk/validation/errors.d.ts

@@ -0,0 +1,30 @@
+import * as v from 'valibot';
+export declare const validationFailedErrorSchema: v.ObjectSchema<{
+    readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>;
+export declare const notAuthenticatedErrorSchema: v.ObjectSchema<{
+    readonly code: v.LiteralSchema<"NOT_AUTHENTICATED", undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>;
+export declare const authenticationFailedErrorSchema: v.ObjectSchema<{
+    readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    readonly details: v.StringSchema<undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>;
+export declare const errorManifest: {
+    authenticationFailedErrorSchema: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+        readonly details: v.StringSchema<undefined>;
+        readonly status: v.LiteralSchema<400, undefined>;
+    }, undefined>;
+    notAuthenticatedErrorSchema: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"NOT_AUTHENTICATED", undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    validationFailedErrorSchema: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly status: v.LiteralSchema<400, undefined>;
+    }, undefined>;
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/sdk/validation/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/errors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAQ5B,eAAO,MAAM,2BAA2B;;;aAGtC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;aAGtC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;aAI1C,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;CAID,CAAA"}

package/dist/sdk/validation/errors.js

@@ -0,0 +1,19 @@
+import * as v from 'valibot';
+export const validationFailedErrorSchema = v.object({
+    code: v.literal('VALIDATION_FAILED'),
+    status: v.literal(400),
+});
+export const notAuthenticatedErrorSchema = v.object({
+    code: v.literal('NOT_AUTHENTICATED'),
+    status: v.literal(401),
+});
+export const authenticationFailedErrorSchema = v.object({
+    code: v.literal('AUTHENTICATION_FAILED'),
+    details: v.string(),
+    status: v.literal(400),
+});
+export const errorManifest = {
+    authenticationFailedErrorSchema,
+    notAuthenticatedErrorSchema,
+    validationFailedErrorSchema,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "2.0.116",
+  "version": "2.0.118",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",

package/dist/sdk/endpoints/private/emailMessage/getText.d.ts

@@ -1,16 +0,0 @@
-import * as v from 'valibot';
-export declare const getText: import("../../../../types").EndpointConfig<"/v1/pv/email-message/:messageId/text", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"::UNAUTHENTICATED", undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"GET_TEXT::MESSAGE_NOT_FOUND", undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly hasMore: v.BooleanSchema<undefined>;
-        readonly html: v.UndefinedableSchema<v.StringSchema<undefined>, undefined>;
-        readonly text: v.UndefinedableSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=getText.d.ts.map

package/dist/sdk/endpoints/private/emailMessage/getText.d.ts.map

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

package/dist/sdk/endpoints/private/emailMessage/getText.js

@@ -1,23 +0,0 @@
-import * as v from 'valibot';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../../types';
-export const getText = createEndpoint({
-    method: HTTPMethod.GET,
-    path: '/v1/pv/email-message/:messageId/text',
-    response: v.union([
-        errorManifest.unauthenticatedErrorSchema,
-        v.object({
-            code: v.literal('GET_TEXT::MESSAGE_NOT_FOUND'),
-            status: v.literal(404),
-        }),
-        v.object({
-            data: v.object({
-                hasMore: v.boolean(),
-                html: v.undefinedable(v.string()),
-                text: v.undefinedable(v.string()),
-            }),
-            status: v.literal(200),
-        }),
-    ]),
-});

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

@@ -1,17 +0,0 @@
-export declare const emailMessage: {
-    getText: import("../../../..").EndpointConfig<"/v1/pv/email-message/:messageId/text", 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<"::UNAUTHENTICATED", undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly code: import("valibot").LiteralSchema<"GET_TEXT::MESSAGE_NOT_FOUND", undefined>;
-        readonly status: import("valibot").LiteralSchema<404, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly hasMore: import("valibot").BooleanSchema<undefined>;
-            readonly html: import("valibot").UndefinedableSchema<import("valibot").StringSchema<undefined>, undefined>;
-            readonly text: import("valibot").UndefinedableSchema<import("valibot").StringSchema<undefined>, undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<200, undefined>;
-    }, undefined>], undefined>>;
-};
-//# sourceMappingURL=index.d.ts.map

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

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

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

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

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

@@ -1,8 +0,0 @@
-import * as v from 'valibot';
-export declare const deleteUser: import("../../../../types").EndpointConfig<"/v1/pv/user", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"::UNAUTHENTICATED", 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

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

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

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

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

@@ -1,9 +0,0 @@
-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<"::UNAUTHENTICATED", 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

@@ -1 +0,0 @@
-{"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

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

package/dist/sdk/endpoints/webhook/emailEngine.d.ts

@@ -1,8 +0,0 @@
-import * as v from 'valibot';
-export declare const emailEngine: import("../../../types").EndpointConfig<"/v1/wh/email-engine", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly code: v.LiteralSchema<"::UNAUTHENTICATED", undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=emailEngine.d.ts.map

package/dist/sdk/endpoints/webhook/emailEngine.d.ts.map

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

package/dist/sdk/endpoints/webhook/emailEngine.js

@@ -1,12 +0,0 @@
-import * as v from 'valibot';
-import { createEndpoint } from '../../../sdk/endpoints/createEndpointConfig';
-import { errorManifest } from '../../../sdk/validation/errors';
-import { HTTPMethod } from '../../../types';
-export const emailEngine = createEndpoint({
-    method: HTTPMethod.POST,
-    path: '/v1/wh/email-engine',
-    response: v.union([
-        errorManifest.unauthenticatedErrorSchema,
-        v.object({ status: v.literal(200) }),
-    ]),
-});