@marcoappio/marco-config 2.0.286 → 2.0.288

package/dist/clients/account.d.ts

@@ -1,6 +1,12 @@
 import * as v from 'valibot';
 export declare const account: {
     model: v.ObjectSchema<{
+        readonly aliases: v.ArraySchema<v.ObjectSchema<{
+            readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            readonly isHidden: v.BooleanSchema<undefined>;
+            readonly isPrimary: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>;
         readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
         readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
         readonly imapConnectionStatus: v.UnionSchema<[v.LiteralSchema<"AWAITING_CONNECTION", undefined>, v.LiteralSchema<"CONNECTED", undefined>, v.LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
@@ -27,11 +33,34 @@ export declare const account: {
                 readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
             }, undefined>;
         };
+        createAlias: {
+            delta: v.ObjectSchema<{
+                readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly isHidden: v.BooleanSchema<undefined>;
+                readonly isPrimary: v.BooleanSchema<undefined>;
+            }, undefined>;
+        };
         delete: {
             delta: v.ObjectSchema<{
                 readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
             }, undefined>;
         };
+        deleteAlias: {
+            delta: v.ObjectSchema<{
+                readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            }, undefined>;
+        };
+        setAliasHidden: {
+            delta: v.ObjectSchema<{
+                readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            }, undefined>;
+        };
+        setAliasPrimary: {
+            delta: v.ObjectSchema<{
+                readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            }, undefined>;
+        };
         setConnectionConfig: {
             delta: v.ObjectSchema<{
                 readonly connectionConfig: v.ObjectSchema<{
@@ -105,8 +134,8 @@ export declare const account: {
         };
     };
     name: "account";
-    pullURL: "/v1/pv/sync/pull/account";
-    pushURL: "/v1/pv/sync/push/account";
+    pullUrl: "/v1/pv/sync/pull/account";
+    pushUrl: "/v1/pv/sync/push/account";
     schemaVersion: "v1";
 };
 //# sourceMappingURL=account.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/clients/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DG,CAAA"}
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/clients/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FG,CAAA"}

package/dist/clients/account.js

@@ -6,6 +6,12 @@ const accountSettings = v.object({
 });
 export const account = {
     model: v.object({
+        aliases: v.array(v.object({
+            emailAddress: marcoSchemas.string.email(),
+            id: marcoSchemas.string.shortUUID(),
+            isHidden: v.boolean(),
+            isPrimary: v.boolean(),
+        })),
         emailAddress: marcoSchemas.string.email(),
         id: marcoSchemas.string.shortUUID(),
         imapConnectionStatus: marcoSchemas.emailAccount.imapConnectionStatus(),
@@ -29,11 +35,34 @@ export const account = {
                 id: marcoSchemas.string.shortUUID(),
             }),
         },
+        createAlias: {
+            delta: v.object({
+                aliasId: marcoSchemas.string.shortUUID(),
+                emailAddress: marcoSchemas.string.email(),
+                isHidden: v.boolean(),
+                isPrimary: v.boolean(),
+            }),
+        },
         delete: {
             delta: v.object({
                 id: marcoSchemas.string.shortUUID(),
             }),
         },
+        deleteAlias: {
+            delta: v.object({
+                aliasId: marcoSchemas.string.shortUUID(),
+            }),
+        },
+        setAliasHidden: {
+            delta: v.object({
+                aliasId: marcoSchemas.string.shortUUID(),
+            }),
+        },
+        setAliasPrimary: {
+            delta: v.object({
+                aliasId: marcoSchemas.string.shortUUID(),
+            }),
+        },
         setConnectionConfig: {
             delta: v.object({
                 connectionConfig: marcoSchemas.emailAccount.connectionConfigImapRaw(),
@@ -60,7 +89,7 @@ export const account = {
         },
     },
     name: 'account',
-    pullURL: '/v1/pv/sync/pull/account',
-    pushURL: '/v1/pv/sync/push/account',
+    pullUrl: '/v1/pv/sync/pull/account',
+    pushUrl: '/v1/pv/sync/push/account',
     schemaVersion: 'v1',
 };

package/dist/clients/contact.d.ts

@@ -7,8 +7,8 @@ export declare const contact: {
     }, undefined>;
     mutators: {};
     name: "contact";
-    pullURL: "/v1/pv/sync/pull/contact";
-    pushURL: null;
+    pullUrl: "/v1/pv/sync/pull/contact";
+    pushUrl: null;
     schemaVersion: "v1";
 };
 //# sourceMappingURL=contact.d.ts.map

package/dist/clients/contact.js

@@ -8,7 +8,7 @@ export const contact = {
     }),
     mutators: {},
     name: 'contact',
-    pullURL: '/v1/pv/sync/pull/contact',
-    pushURL: null,
+    pullUrl: '/v1/pv/sync/pull/contact',
+    pushUrl: null,
     schemaVersion: 'v1',
 };

package/dist/clients/draft.d.ts

@@ -163,8 +163,8 @@ export declare const draft: {
         };
     };
     name: "draft";
-    pullURL: "/v1/pv/sync/pull/draft";
-    pushURL: "/v1/pv/sync/push/draft";
+    pullUrl: "/v1/pv/sync/pull/draft";
+    pushUrl: "/v1/pv/sync/push/draft";
     schemaVersion: "v1";
 };
 //# sourceMappingURL=draft.d.ts.map

package/dist/clients/draft.js

@@ -96,7 +96,7 @@ export const draft = {
         },
     },
     name: 'draft',
-    pullURL: '/v1/pv/sync/pull/draft',
-    pushURL: '/v1/pv/sync/push/draft',
+    pullUrl: '/v1/pv/sync/pull/draft',
+    pushUrl: '/v1/pv/sync/push/draft',
     schemaVersion: 'v1',
 };

package/dist/clients/index.d.ts

@@ -2,6 +2,12 @@ export { marcoClientsUtils } from './utils';
 export declare const marcoClients: {
     account: {
         model: import("valibot").ObjectSchema<{
+            readonly aliases: import("valibot").ArraySchema<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").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                readonly isHidden: import("valibot").BooleanSchema<undefined>;
+                readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+            }, undefined>, undefined>;
             readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
             readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
             readonly imapConnectionStatus: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
@@ -28,11 +34,34 @@ export declare const marcoClients: {
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                 }, undefined>;
             };
+            createAlias: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                    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 isHidden: import("valibot").BooleanSchema<undefined>;
+                    readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                }, undefined>;
+            };
             delete: {
                 delta: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                 }, undefined>;
             };
+            deleteAlias: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                }, undefined>;
+            };
+            setAliasHidden: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                }, undefined>;
+            };
+            setAliasPrimary: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                }, undefined>;
+            };
             setConnectionConfig: {
                 delta: import("valibot").ObjectSchema<{
                     readonly connectionConfig: import("valibot").ObjectSchema<{
@@ -106,8 +135,8 @@ export declare const marcoClients: {
             };
         };
         name: "account";
-        pullURL: "/v1/pv/sync/pull/account";
-        pushURL: "/v1/pv/sync/push/account";
+        pullUrl: "/v1/pv/sync/pull/account";
+        pushUrl: "/v1/pv/sync/push/account";
         schemaVersion: "v1";
     };
     contact: {
@@ -118,8 +147,8 @@ export declare const marcoClients: {
         }, undefined>;
         mutators: {};
         name: "contact";
-        pullURL: "/v1/pv/sync/pull/contact";
-        pushURL: null;
+        pullUrl: "/v1/pv/sync/pull/contact";
+        pushUrl: null;
         schemaVersion: "v1";
     };
     draft: {
@@ -286,8 +315,8 @@ export declare const marcoClients: {
             };
         };
         name: "draft";
-        pullURL: "/v1/pv/sync/pull/draft";
-        pushURL: "/v1/pv/sync/push/draft";
+        pullUrl: "/v1/pv/sync/pull/draft";
+        pushUrl: "/v1/pv/sync/push/draft";
         schemaVersion: "v1";
     };
     thread: {
@@ -377,8 +406,8 @@ export declare const marcoClients: {
             };
         };
         name: "thread";
-        pullURL: "/v1/pv/sync/pull/thread";
-        pushURL: "/v1/pv/sync/push/thread";
+        pullUrl: "/v1/pv/sync/pull/thread";
+        pushUrl: "/v1/pv/sync/push/thread";
         schemaVersion: "v1";
     };
     user: {
@@ -420,8 +449,8 @@ export declare const marcoClients: {
             };
         };
         name: "user";
-        pullURL: "/v1/pv/sync/pull/user";
-        pushURL: "/v1/pv/sync/push/user";
+        pullUrl: "/v1/pv/sync/pull/user";
+        pushUrl: "/v1/pv/sync/push/user";
         schemaVersion: "v1";
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clients/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clients/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMc,CAAA"}

package/dist/clients/thread.d.ts

@@ -86,8 +86,8 @@ export declare const thread: {
         };
     };
     name: "thread";
-    pullURL: "/v1/pv/sync/pull/thread";
-    pushURL: "/v1/pv/sync/push/thread";
+    pullUrl: "/v1/pv/sync/pull/thread";
+    pushUrl: "/v1/pv/sync/push/thread";
     schemaVersion: "v1";
 };
 //# sourceMappingURL=thread.d.ts.map

package/dist/clients/thread.js

@@ -81,7 +81,7 @@ export const thread = {
         },
     },
     name: 'thread',
-    pullURL: '/v1/pv/sync/pull/thread',
-    pushURL: '/v1/pv/sync/push/thread',
+    pullUrl: '/v1/pv/sync/pull/thread',
+    pushUrl: '/v1/pv/sync/push/thread',
     schemaVersion: 'v1',
 };

package/dist/clients/user.d.ts

@@ -38,8 +38,8 @@ export declare const user: {
         };
     };
     name: "user";
-    pullURL: "/v1/pv/sync/pull/user";
-    pushURL: "/v1/pv/sync/push/user";
+    pullUrl: "/v1/pv/sync/pull/user";
+    pushUrl: "/v1/pv/sync/push/user";
     schemaVersion: "v1";
 };
 //# sourceMappingURL=user.d.ts.map

package/dist/clients/user.js

@@ -17,7 +17,7 @@ export const user = {
         },
     },
     name: 'user',
-    pullURL: '/v1/pv/sync/pull/user',
-    pushURL: '/v1/pv/sync/push/user',
+    pullUrl: '/v1/pv/sync/pull/user',
+    pushUrl: '/v1/pv/sync/push/user',
     schemaVersion: 'v1',
 };

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

@@ -100,6 +100,12 @@ export declare const endpoints: {
                             readonly key: import("valibot").StringSchema<undefined>;
                             readonly op: import("valibot").LiteralSchema<"put", undefined>;
                             readonly value: import("valibot").ObjectSchema<{
+                                readonly aliases: import("valibot").ArraySchema<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").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                                    readonly isHidden: import("valibot").BooleanSchema<undefined>;
+                                    readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                                }, undefined>, undefined>;
                                 readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                 readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                                 readonly imapConnectionStatus: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
@@ -361,6 +367,16 @@ export declare const endpoints: {
                         readonly clientID: import("valibot").StringSchema<undefined>;
                         readonly id: import("valibot").NumberSchema<undefined>;
                         readonly name: import("valibot").LiteralSchema<"add", undefined>;
+                    }, undefined> | import("valibot").ObjectSchema<{
+                        readonly args: import("valibot").ObjectSchema<{
+                            readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                            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 isHidden: import("valibot").BooleanSchema<undefined>;
+                            readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                        }, undefined>;
+                        readonly clientID: import("valibot").StringSchema<undefined>;
+                        readonly id: import("valibot").NumberSchema<undefined>;
+                        readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
                     }, undefined> | import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
                             readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -368,6 +384,27 @@ export declare const endpoints: {
                         readonly clientID: import("valibot").StringSchema<undefined>;
                         readonly id: import("valibot").NumberSchema<undefined>;
                         readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+                    }, undefined> | import("valibot").ObjectSchema<{
+                        readonly args: import("valibot").ObjectSchema<{
+                            readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                        }, undefined>;
+                        readonly clientID: import("valibot").StringSchema<undefined>;
+                        readonly id: import("valibot").NumberSchema<undefined>;
+                        readonly name: import("valibot").LiteralSchema<"deleteAlias", undefined>;
+                    }, undefined> | import("valibot").ObjectSchema<{
+                        readonly args: import("valibot").ObjectSchema<{
+                            readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                        }, undefined>;
+                        readonly clientID: import("valibot").StringSchema<undefined>;
+                        readonly id: import("valibot").NumberSchema<undefined>;
+                        readonly name: import("valibot").LiteralSchema<"setAliasHidden", undefined>;
+                    }, undefined> | import("valibot").ObjectSchema<{
+                        readonly args: import("valibot").ObjectSchema<{
+                            readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                        }, undefined>;
+                        readonly clientID: import("valibot").StringSchema<undefined>;
+                        readonly id: import("valibot").NumberSchema<undefined>;
+                        readonly name: import("valibot").LiteralSchema<"setAliasPrimary", undefined>;
                     }, undefined> | import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
                             readonly connectionConfig: import("valibot").ObjectSchema<{

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

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

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

@@ -97,6 +97,12 @@ export declare const privateGroup: {
                         readonly key: import("valibot").StringSchema<undefined>;
                         readonly op: import("valibot").LiteralSchema<"put", undefined>;
                         readonly value: import("valibot").ObjectSchema<{
+                            readonly aliases: import("valibot").ArraySchema<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").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                                readonly isHidden: import("valibot").BooleanSchema<undefined>;
+                                readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                            }, undefined>, undefined>;
                             readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                             readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                             readonly imapConnectionStatus: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
@@ -358,6 +364,16 @@ export declare const privateGroup: {
                     readonly clientID: import("valibot").StringSchema<undefined>;
                     readonly id: import("valibot").NumberSchema<undefined>;
                     readonly name: import("valibot").LiteralSchema<"add", undefined>;
+                }, undefined> | import("valibot").ObjectSchema<{
+                    readonly args: import("valibot").ObjectSchema<{
+                        readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                        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 isHidden: import("valibot").BooleanSchema<undefined>;
+                        readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
                 }, undefined> | import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
                         readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -365,6 +381,27 @@ export declare const privateGroup: {
                     readonly clientID: import("valibot").StringSchema<undefined>;
                     readonly id: import("valibot").NumberSchema<undefined>;
                     readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+                }, undefined> | import("valibot").ObjectSchema<{
+                    readonly args: import("valibot").ObjectSchema<{
+                        readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"deleteAlias", undefined>;
+                }, undefined> | import("valibot").ObjectSchema<{
+                    readonly args: import("valibot").ObjectSchema<{
+                        readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"setAliasHidden", undefined>;
+                }, undefined> | import("valibot").ObjectSchema<{
+                    readonly args: import("valibot").ObjectSchema<{
+                        readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"setAliasPrimary", undefined>;
                 }, undefined> | import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
                         readonly connectionConfig: import("valibot").ObjectSchema<{

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

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

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

@@ -31,6 +31,12 @@ export declare const sync: {
                     readonly key: import("valibot").StringSchema<undefined>;
                     readonly op: import("valibot").LiteralSchema<"put", undefined>;
                     readonly value: import("valibot").ObjectSchema<{
+                        readonly aliases: import("valibot").ArraySchema<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").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                            readonly isHidden: import("valibot").BooleanSchema<undefined>;
+                            readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                        }, undefined>, undefined>;
                         readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                         readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                         readonly imapConnectionStatus: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
@@ -292,6 +298,16 @@ export declare const sync: {
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
                 readonly name: import("valibot").LiteralSchema<"add", undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                    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 isHidden: import("valibot").BooleanSchema<undefined>;
+                    readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -299,6 +315,27 @@ export declare const sync: {
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
                 readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"deleteAlias", undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"setAliasHidden", undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"setAliasPrimary", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly connectionConfig: import("valibot").ObjectSchema<{

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

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

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

@@ -30,6 +30,12 @@ export declare const syncPullAccount: import("../../../../..").EndpointConfig<"/
             readonly key: v.StringSchema<undefined>;
             readonly op: v.LiteralSchema<"put", undefined>;
             readonly value: v.ObjectSchema<{
+                readonly aliases: v.ArraySchema<v.ObjectSchema<{
+                    readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                    readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                    readonly isHidden: v.BooleanSchema<undefined>;
+                    readonly isPrimary: v.BooleanSchema<undefined>;
+                }, undefined>, undefined>;
                 readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                 readonly imapConnectionStatus: v.UnionSchema<[v.LiteralSchema<"AWAITING_CONNECTION", undefined>, v.LiteralSchema<"CONNECTED", undefined>, v.LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;

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

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

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

@@ -8,7 +8,7 @@ export const syncPullAccount = createEndpoint({
         cookie: v.nullable(v.number()),
     }),
     method: 'POST',
-    path: account.pullURL,
+    path: account.pullUrl,
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,

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

@@ -8,7 +8,7 @@ export const syncPullContact = createEndpoint({
         cookie: v.nullable(v.number()),
     }),
     method: 'POST',
-    path: contact.pullURL,
+    path: contact.pullUrl,
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,

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

@@ -8,7 +8,7 @@ export const syncPullDraft = createEndpoint({
         cookie: v.nullable(v.number()),
     }),
     method: 'POST',
-    path: draft.pullURL,
+    path: draft.pullUrl,
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,

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

@@ -30,6 +30,12 @@ export declare const pull: {
                 readonly key: import("valibot").StringSchema<undefined>;
                 readonly op: import("valibot").LiteralSchema<"put", undefined>;
                 readonly value: import("valibot").ObjectSchema<{
+                    readonly aliases: import("valibot").ArraySchema<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").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                        readonly isHidden: import("valibot").BooleanSchema<undefined>;
+                        readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                    }, undefined>, undefined>;
                     readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                     readonly imapConnectionStatus: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;

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

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

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

@@ -15,7 +15,7 @@ export const syncPullThread = createEndpoint({
         })),
     }),
     method: 'POST',
-    path: thread.pullURL,
+    path: thread.pullUrl,
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,

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

@@ -8,7 +8,7 @@ export const syncPullUser = createEndpoint({
         cookie: v.nullable(v.number()),
     }),
     method: 'POST',
-    path: user.pullURL,
+    path: user.pullUrl,
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,

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

@@ -10,6 +10,16 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
         readonly name: v.LiteralSchema<"add", undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly isHidden: v.BooleanSchema<undefined>;
+            readonly isPrimary: v.BooleanSchema<undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"createAlias", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -17,6 +27,27 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
         readonly name: v.LiteralSchema<"delete", undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"deleteAlias", undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"setAliasHidden", undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly aliasId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"setAliasPrimary", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly connectionConfig: v.ObjectSchema<{

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

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

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

@@ -12,12 +12,36 @@ export const syncPushAccount = createEndpoint({
                 id: v.number(),
                 name: v.literal('add'),
             }),
+            createAlias: v.object({
+                args: account.mutators.createAlias.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('createAlias'),
+            }),
             delete: v.object({
                 args: account.mutators.delete.delta,
                 clientID: v.string(),
                 id: v.number(),
                 name: v.literal('delete'),
             }),
+            deleteAlias: v.object({
+                args: account.mutators.deleteAlias.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('deleteAlias'),
+            }),
+            setAliasHidden: v.object({
+                args: account.mutators.setAliasHidden.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('setAliasHidden'),
+            }),
+            setAliasPrimary: v.object({
+                args: account.mutators.setAliasPrimary.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('setAliasPrimary'),
+            }),
             setConnectionConfig: v.object({
                 args: account.mutators.setConnectionConfig.delta,
                 clientID: v.string(),
@@ -45,7 +69,7 @@ export const syncPushAccount = createEndpoint({
         }))),
     }),
     method: 'POST',
-    path: account.pushURL,
+    path: account.pushUrl,
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,

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

@@ -63,7 +63,7 @@ export const syncPushDraft = createEndpoint({
         }))),
     }),
     method: 'POST',
-    path: draft.pushURL,
+    path: draft.pushUrl,
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,

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

@@ -10,6 +10,16 @@ export declare const push: {
             readonly clientID: import("valibot").StringSchema<undefined>;
             readonly id: import("valibot").NumberSchema<undefined>;
             readonly name: import("valibot").LiteralSchema<"add", undefined>;
+        }, undefined> | import("valibot").ObjectSchema<{
+            readonly args: import("valibot").ObjectSchema<{
+                readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                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 isHidden: import("valibot").BooleanSchema<undefined>;
+                readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+            }, undefined>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
         }, undefined> | import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
                 readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -17,6 +27,27 @@ export declare const push: {
             readonly clientID: import("valibot").StringSchema<undefined>;
             readonly id: import("valibot").NumberSchema<undefined>;
             readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+        }, undefined> | import("valibot").ObjectSchema<{
+            readonly args: import("valibot").ObjectSchema<{
+                readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            }, undefined>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"deleteAlias", undefined>;
+        }, undefined> | import("valibot").ObjectSchema<{
+            readonly args: import("valibot").ObjectSchema<{
+                readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            }, undefined>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"setAliasHidden", undefined>;
+        }, undefined> | import("valibot").ObjectSchema<{
+            readonly args: import("valibot").ObjectSchema<{
+                readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+            }, undefined>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"setAliasPrimary", undefined>;
         }, undefined> | import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
                 readonly connectionConfig: import("valibot").ObjectSchema<{

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

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

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

@@ -57,7 +57,7 @@ export const syncPushThread = createEndpoint({
         }))),
     }),
     method: 'POST',
-    path: thread.pushURL,
+    path: thread.pushUrl,
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,

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

@@ -15,7 +15,7 @@ export const syncPushUser = createEndpoint({
         }))),
     }),
     method: 'POST',
-    path: user.pushURL,
+    path: user.pushUrl,
     response: v.union([
         errors.validationFailedErrorSchema,
         errors.authFailedErrorSchema,

package/dist/sdk/index.d.ts

@@ -99,6 +99,12 @@ export declare const marcoSDK: {
                                 readonly key: import("valibot").StringSchema<undefined>;
                                 readonly op: import("valibot").LiteralSchema<"put", undefined>;
                                 readonly value: import("valibot").ObjectSchema<{
+                                    readonly aliases: import("valibot").ArraySchema<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").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                                        readonly isHidden: import("valibot").BooleanSchema<undefined>;
+                                        readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                                    }, undefined>, undefined>;
                                     readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
                                     readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
                                     readonly imapConnectionStatus: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
@@ -360,6 +366,16 @@ export declare const marcoSDK: {
                             readonly clientID: import("valibot").StringSchema<undefined>;
                             readonly id: import("valibot").NumberSchema<undefined>;
                             readonly name: import("valibot").LiteralSchema<"add", undefined>;
+                        }, undefined> | import("valibot").ObjectSchema<{
+                            readonly args: import("valibot").ObjectSchema<{
+                                readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                                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 isHidden: import("valibot").BooleanSchema<undefined>;
+                                readonly isPrimary: import("valibot").BooleanSchema<undefined>;
+                            }, undefined>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
                         }, undefined> | import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
                                 readonly id: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
@@ -367,6 +383,27 @@ export declare const marcoSDK: {
                             readonly clientID: import("valibot").StringSchema<undefined>;
                             readonly id: import("valibot").NumberSchema<undefined>;
                             readonly name: import("valibot").LiteralSchema<"delete", undefined>;
+                        }, undefined> | import("valibot").ObjectSchema<{
+                            readonly args: import("valibot").ObjectSchema<{
+                                readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                            }, undefined>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"deleteAlias", undefined>;
+                        }, undefined> | import("valibot").ObjectSchema<{
+                            readonly args: import("valibot").ObjectSchema<{
+                                readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                            }, undefined>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"setAliasHidden", undefined>;
+                        }, undefined> | import("valibot").ObjectSchema<{
+                            readonly args: import("valibot").ObjectSchema<{
+                                readonly aliasId: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string | import("short-uuid").SUUID, "Invalid short UUID format">]>;
+                            }, undefined>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"setAliasPrimary", undefined>;
                         }, undefined> | import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
                                 readonly connectionConfig: import("valibot").ObjectSchema<{

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

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

package/dist/types/MarcoClient.d.ts

@@ -6,8 +6,8 @@ export type MarcoClient = {
         delta: v.ObjectSchema<any, any>;
     }>;
     name: string;
-    pullURL: string;
-    pushURL: string | null;
+    pullUrl: string;
+    pushUrl: string | null;
     schemaVersion: string;
 };
 export type LabelSpecialUse = v.InferOutput<ReturnType<typeof marcoSchemas.labelSpecialUse>>;

package/package.json

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