npm - @marcoappio/marco-config - Versions diffs - 2.0.116 → 2.0.118 - Mend

@marcoappio/marco-config 2.0.116 → 2.0.118

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/dist/clients/account.d.ts CHANGED Viewed

@@ -11,6 +11,7 @@ export declare const account: {
             readonly status: v.EnumSchema<typeof IMAPPasswordConfigStatus, undefined>;
         }, undefined>, undefined>;
         readonly labels: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly name: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly path: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
         }, undefined>, undefined>;

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

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

package/dist/clients/account.js CHANGED Viewed

@@ -13,6 +13,7 @@ export const account = {
         id: marcoSchemas.string.required(),
         imapPasswordConfig: v.nullable(imapPasswordConfig),
         labels: v.array(v.object({
+            id: marcoSchemas.string.required(),
             name: marcoSchemas.string.required(),
             path: marcoSchemas.string.required(),
         })),

package/dist/clients/index.d.ts CHANGED Viewed

@@ -10,6 +10,7 @@ export declare const marcoClients: {
                 readonly status: import("valibot").EnumSchema<typeof import("../types").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>;

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

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

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

@@ -2,29 +2,83 @@ import { GenericSchema } from 'valibot';
 import { EndpointConfig } from '../../types';
 export declare const endpoints: {
     private: {
-        emailMessage: {
-            getText: EndpointConfig<"/v1/pv/email-message/:messageId/text", GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, 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: EndpointConfig<"/v1/pv/user", GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, 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: 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>, 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("../../types").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: 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("../../types").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>, 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: {
@@ -32,7 +86,7 @@ export declare const endpoints: {
             refreshAuth: EndpointConfig<"/v1/pb/auth/refresh", import("valibot").ObjectSchema<{
                 readonly refreshToken: import("valibot").StringSchema<undefined>;
             }, undefined>, 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>;
@@ -52,7 +106,7 @@ export declare const endpoints: {
             sendAuthCode: 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>, 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>;
@@ -61,7 +115,7 @@ export declare const endpoints: {
                 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>, 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>;
@@ -86,13 +140,5 @@ export declare const endpoints: {
             readonly status: import("valibot").LiteralSchema<200, undefined>;
         }, undefined>>;
     };
-    webhook: {
-        emailEngine: EndpointConfig<"/v1/wh/email-engine", GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, 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>>;
-    };
 };
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/sdk/endpoints/index.js CHANGED Viewed

@@ -1,8 +1,6 @@
 import { privateGroup } from './private';
 import { publicGroup } from './public';
-import { webhook } from './webhook';
 export const endpoints = {
     private: privateGroup,
     public: publicGroup,
-    webhook,
 };

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

@@ -1,27 +1,81 @@
 export declare const privateGroup: {
-    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>>;
+        };
     };
 };
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,6 +1,4 @@
-import { emailMessage } from './emailMessage';
-import { user } from './user';
+import { sync } from './sync';
 export const privateGroup = {
-    emailMessage,
-    user,
+    sync,
 };

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

@@ -0,0 +1,79 @@
+export declare const 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>>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/sdk/endpoints/private/sync/index.js ADDED Viewed

@@ -0,0 +1,3 @@
+import { pull } from './pull';
+import { push } from './push';
+export const sync = { pull, push };

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

@@ -0,0 +1,42 @@
+import * as v from 'valibot';
+export declare const syncPullAccount: import("../../../../../types").EndpointConfig<"/v1/pv/sync/pull/account", v.ObjectSchema<{
+    readonly clientGroupID: v.StringSchema<undefined>;
+    readonly cookie: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
+    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 data: v.ObjectSchema<{
+        readonly cookie: v.NumberSchema<undefined>;
+        readonly lastMutationIDChanges: v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>;
+        readonly patch: v.ArraySchema<v.UnionSchema<[v.ObjectSchema<{
+            readonly key: v.StringSchema<undefined>;
+            readonly op: v.LiteralSchema<"del", undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly op: v.LiteralSchema<"clear", undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly key: v.StringSchema<undefined>;
+            readonly op: v.LiteralSchema<"put", undefined>;
+            readonly value: v.ObjectSchema<{
+                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly imapPasswordConfig: v.NullableSchema<v.ObjectSchema<{
+                    readonly host: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly password: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly port: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
+                    readonly status: v.EnumSchema<typeof import("../../../../../types").IMAPPasswordConfigStatus, undefined>;
+                }, undefined>, undefined>;
+                readonly labels: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly name: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly path: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=account.d.ts.map

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

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

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

@@ -0,0 +1,29 @@
+import * as v from 'valibot';
+import { account } from '../../../../../clients/account';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { errorManifest } from '../../../../../sdk/validation/errors';
+import { HTTPMethod } from '../../../../../types';
+export const syncPullAccount = createEndpoint({
+    body: v.object({
+        clientGroupID: v.string(),
+        cookie: v.nullable(v.number()),
+    }),
+    method: HTTPMethod.POST,
+    path: account.pullURL,
+    response: v.union([
+        errorManifest.validationFailedErrorSchema,
+        errorManifest.notAuthenticatedErrorSchema,
+        v.object({
+            data: v.object({
+                cookie: v.number(),
+                lastMutationIDChanges: v.record(v.string(), v.number()),
+                patch: v.array(v.union([
+                    v.object({ key: v.string(), op: v.literal('del') }),
+                    v.object({ op: v.literal('clear') }),
+                    v.object({ key: v.string(), op: v.literal('put'), value: account.model }),
+                ])),
+            }),
+            status: v.literal(200),
+        }),
+    ]),
+});

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

@@ -0,0 +1,43 @@
+export declare const 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>>;
+};
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/sdk/endpoints/private/sync/pull/index.js ADDED Viewed

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