@marcoappio/marco-config 2.0.309 → 2.0.311

package/dist/clients/account.d.ts

@@ -1,11 +1,20 @@
 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.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
-            readonly primary: v.BooleanSchema<undefined>;
-        }, undefined>, undefined>;
+        readonly aliases: v.ObjectSchema<{
+            readonly nonPrimary: 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.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly primary: v.BooleanSchema<undefined>;
+            }, undefined>, undefined>;
+            readonly primary: v.ObjectSchema<{
+                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly primary: 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.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
         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>;
@@ -39,6 +48,7 @@ export declare const account: {
                 readonly alias: v.ObjectSchema<{
                     readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                     readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                    readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly primary: v.BooleanSchema<undefined>;
                 }, undefined>;
             }, undefined>;
@@ -54,6 +64,13 @@ export declare const account: {
                 readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
             }, undefined>;
         };
+        setAliasName: {
+            delta: v.ObjectSchema<{
+                readonly accountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
         setAliasPrimary: {
             delta: v.ObjectSchema<{
                 readonly accountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;

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;AAgB5B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EG,CAAA"}
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/clients/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAiB5B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqFG,CAAA"}

package/dist/clients/account.js

@@ -7,11 +7,15 @@ const accountSettingsSchema = v.object({
 const aliasSchema = v.object({
     emailAddress: marcoSchemas.string.email(),
     id: marcoSchemas.string.shortUUID(),
+    name: marcoSchemas.string.nullable(),
     primary: v.boolean(),
 });
 export const account = {
     model: v.object({
-        aliases: v.array(aliasSchema),
+        aliases: v.object({
+            nonPrimary: v.array(aliasSchema),
+            primary: aliasSchema,
+        }),
         emailAddress: marcoSchemas.string.email(),
         id: marcoSchemas.string.shortUUID(),
         imapConnectionStatus: marcoSchemas.emailAccount.imapConnectionStatus(),
@@ -53,6 +57,13 @@ export const account = {
                 aliasId: marcoSchemas.string.shortUUID(),
             }),
         },
+        setAliasName: {
+            delta: v.object({
+                accountId: marcoSchemas.string.shortUUID(),
+                aliasId: marcoSchemas.string.shortUUID(),
+                name: marcoSchemas.string.nullable(),
+            }),
+        },
         setAliasPrimary: {
             delta: v.object({
                 accountId: marcoSchemas.string.shortUUID(),

package/dist/clients/draft.d.ts

@@ -1,6 +1,7 @@
 import * as v from 'valibot';
 export declare const draft: {
     model: v.ObjectSchema<{
+        readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
         readonly attachments: v.ArraySchema<v.ObjectSchema<{
             readonly failed: v.BooleanSchema<undefined>;
             readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -17,7 +18,7 @@ export declare const draft: {
             readonly subject: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
         }, undefined>;
-        readonly emailAccountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+        readonly emailAccountId: v.OptionalSchema<v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;
         readonly error: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
         readonly referencedMessageId: v.NullableSchema<v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;
@@ -50,6 +51,7 @@ export declare const draft: {
         };
         createDraft: {
             delta: v.ObjectSchema<{
+                readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
                 readonly attachments: v.ArraySchema<v.ObjectSchema<{
                     readonly failed: v.BooleanSchema<undefined>;
                     readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -66,7 +68,7 @@ export declare const draft: {
                     readonly subject: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                 }, undefined>;
-                readonly emailAccountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly emailAccountId: v.OptionalSchema<v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;
                 readonly error: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
                 readonly referencedMessageId: v.NullableSchema<v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;
@@ -94,6 +96,13 @@ export declare const draft: {
                 readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
             }, undefined>;
         };
+        setAliasId: {
+            delta: v.ObjectSchema<{
+                readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+        };
         setContent: {
             delta: v.ObjectSchema<{
                 readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../src/clients/draft.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAmD5B,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EK,CAAA"}
+{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../src/clients/draft.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAoD5B,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqFK,CAAA"}

package/dist/clients/draft.js

@@ -29,9 +29,10 @@ const attachmentSchema = v.object({
 });
 const scheduledForSchema = v.nullable(marcoSchemas.number.positiveInteger());
 const draftSchema = v.object({
+    aliasId: marcoSchemas.string.shortUUID(),
     attachments: v.array(attachmentSchema),
     body: bodySchema,
-    emailAccountId: marcoSchemas.string.shortUUID(),
+    emailAccountId: v.optional(marcoSchemas.string.shortUUID()),
     error: v.nullable(v.string()),
     id: marcoSchemas.string.shortUUID(),
     referencedMessageId: v.nullable(marcoSchemas.string.shortUUID()),
@@ -77,6 +78,13 @@ export const draft = {
                 updatedAt: marcoSchemas.number.positiveInteger(),
             }),
         },
+        setAliasId: {
+            delta: v.object({
+                aliasId: marcoSchemas.string.shortUUID(),
+                id: marcoSchemas.string.shortUUID(),
+                updatedAt: marcoSchemas.number.positiveInteger(),
+            }),
+        },
         setContent: {
             delta: v.object({
                 id: marcoSchemas.string.shortUUID(),

package/dist/clients/index.d.ts

@@ -2,11 +2,20 @@ 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                readonly primary: import("valibot").BooleanSchema<undefined>;
-            }, undefined>, undefined>;
+            readonly aliases: import("valibot").ObjectSchema<{
+                readonly nonPrimary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly primary: import("valibot").BooleanSchema<undefined>;
+                }, undefined>, undefined>;
+                readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
             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>;
@@ -40,6 +49,7 @@ export declare const marcoClients: {
                     readonly alias: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly primary: import("valibot").BooleanSchema<undefined>;
                     }, undefined>;
                 }, undefined>;
@@ -55,6 +65,13 @@ export declare const marcoClients: {
                     readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                 }, undefined>;
             };
+            setAliasName: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+            };
             setAliasPrimary: {
                 delta: import("valibot").ObjectSchema<{
                     readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -139,6 +156,7 @@ export declare const marcoClients: {
     };
     draft: {
         model: import("valibot").ObjectSchema<{
+            readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
             readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                 readonly failed: import("valibot").BooleanSchema<undefined>;
                 readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -155,7 +173,7 @@ export declare const marcoClients: {
                 readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
             }, undefined>;
-            readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+            readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
             readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
             readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
             readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -188,6 +206,7 @@ export declare const marcoClients: {
             };
             createDraft: {
                 delta: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                     readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                         readonly failed: import("valibot").BooleanSchema<undefined>;
                         readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -204,7 +223,7 @@ export declare const marcoClients: {
                         readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                     }, undefined>;
-                    readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                     readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                     readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -232,6 +251,13 @@ export declare const marcoClients: {
                     readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                 }, undefined>;
             };
+            setAliasId: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                }, undefined>;
+            };
             setContent: {
                 delta: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;

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/sdk/endpoints/index.d.ts

@@ -100,11 +100,20 @@ 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                                    readonly primary: import("valibot").BooleanSchema<undefined>;
-                                }, undefined>, undefined>;
+                                readonly aliases: import("valibot").ObjectSchema<{
+                                    readonly nonPrimary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                        readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                        readonly primary: import("valibot").BooleanSchema<undefined>;
+                                    }, undefined>, undefined>;
+                                    readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                        readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                        readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                 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>;
@@ -197,6 +206,7 @@ export declare const endpoints: {
                             readonly key: import("valibot").StringSchema<undefined>;
                             readonly op: import("valibot").LiteralSchema<"put", undefined>;
                             readonly value: import("valibot").ObjectSchema<{
+                                readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                 readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                     readonly failed: import("valibot").BooleanSchema<undefined>;
                                     readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -213,7 +223,7 @@ export declare const endpoints: {
                                     readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                                 }, undefined>;
-                                readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                                 readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                                 readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                 readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -376,6 +386,7 @@ export declare const endpoints: {
                             readonly alias: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly primary: import("valibot").BooleanSchema<undefined>;
                             }, undefined>;
                         }, undefined>;
@@ -397,6 +408,15 @@ export declare const endpoints: {
                         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 accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        }, undefined>;
+                        readonly clientID: import("valibot").StringSchema<undefined>;
+                        readonly id: import("valibot").NumberSchema<undefined>;
+                        readonly name: import("valibot").LiteralSchema<"setAliasName", undefined>;
                     }, undefined> | import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
                             readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -517,6 +537,7 @@ export declare const endpoints: {
                         readonly name: import("valibot").LiteralSchema<"createAttachment", undefined>;
                     }, undefined> | import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
+                            readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                             readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                 readonly failed: import("valibot").BooleanSchema<undefined>;
                                 readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -533,7 +554,7 @@ export declare const endpoints: {
                                 readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                             }, undefined>;
-                            readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                             readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                             readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                             readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -569,6 +590,15 @@ export declare const endpoints: {
                         readonly clientID: import("valibot").StringSchema<undefined>;
                         readonly id: import("valibot").NumberSchema<undefined>;
                         readonly name: import("valibot").LiteralSchema<"sendDraft", undefined>;
+                    }, undefined> | import("valibot").ObjectSchema<{
+                        readonly args: import("valibot").ObjectSchema<{
+                            readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                        }, undefined>;
+                        readonly clientID: import("valibot").StringSchema<undefined>;
+                        readonly id: import("valibot").NumberSchema<undefined>;
+                        readonly name: import("valibot").LiteralSchema<"setAliasId", undefined>;
                     }, undefined> | import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
                             readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;

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

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

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

@@ -97,11 +97,20 @@ 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                                readonly primary: import("valibot").BooleanSchema<undefined>;
-                            }, undefined>, undefined>;
+                            readonly aliases: import("valibot").ObjectSchema<{
+                                readonly nonPrimary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    readonly primary: import("valibot").BooleanSchema<undefined>;
+                                }, undefined>, undefined>;
+                                readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                             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>;
@@ -194,6 +203,7 @@ export declare const privateGroup: {
                         readonly key: import("valibot").StringSchema<undefined>;
                         readonly op: import("valibot").LiteralSchema<"put", undefined>;
                         readonly value: import("valibot").ObjectSchema<{
+                            readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                             readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                 readonly failed: import("valibot").BooleanSchema<undefined>;
                                 readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -210,7 +220,7 @@ export declare const privateGroup: {
                                 readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                             }, undefined>;
-                            readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                             readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                             readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                             readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -373,6 +383,7 @@ export declare const privateGroup: {
                         readonly alias: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly primary: import("valibot").BooleanSchema<undefined>;
                         }, undefined>;
                     }, undefined>;
@@ -394,6 +405,15 @@ export declare const privateGroup: {
                     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 accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"setAliasName", undefined>;
                 }, undefined> | import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
                         readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -514,6 +534,7 @@ export declare const privateGroup: {
                     readonly name: import("valibot").LiteralSchema<"createAttachment", undefined>;
                 }, undefined> | import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
+                        readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                         readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                             readonly failed: import("valibot").BooleanSchema<undefined>;
                             readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -530,7 +551,7 @@ export declare const privateGroup: {
                             readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                         }, undefined>;
-                        readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                         readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                         readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                         readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -566,6 +587,15 @@ export declare const privateGroup: {
                     readonly clientID: import("valibot").StringSchema<undefined>;
                     readonly id: import("valibot").NumberSchema<undefined>;
                     readonly name: import("valibot").LiteralSchema<"sendDraft", undefined>;
+                }, undefined> | import("valibot").ObjectSchema<{
+                    readonly args: import("valibot").ObjectSchema<{
+                        readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"setAliasId", undefined>;
                 }, undefined> | import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
                         readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sdk/endpoints/private/index.ts"],"names":[],"mappings":"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,11 +31,20 @@ 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                            readonly primary: import("valibot").BooleanSchema<undefined>;
-                        }, undefined>, undefined>;
+                        readonly aliases: import("valibot").ObjectSchema<{
+                            readonly nonPrimary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly primary: import("valibot").BooleanSchema<undefined>;
+                            }, undefined>, undefined>;
+                            readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                         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>;
@@ -128,6 +137,7 @@ export declare const sync: {
                     readonly key: import("valibot").StringSchema<undefined>;
                     readonly op: import("valibot").LiteralSchema<"put", undefined>;
                     readonly value: import("valibot").ObjectSchema<{
+                        readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                         readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                             readonly failed: import("valibot").BooleanSchema<undefined>;
                             readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -144,7 +154,7 @@ export declare const sync: {
                             readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                         }, undefined>;
-                        readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                         readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                         readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                         readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -307,6 +317,7 @@ export declare const sync: {
                     readonly alias: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly primary: import("valibot").BooleanSchema<undefined>;
                     }, undefined>;
                 }, undefined>;
@@ -328,6 +339,15 @@ export declare const sync: {
                 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 accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"setAliasName", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -448,6 +468,7 @@ export declare const sync: {
                 readonly name: import("valibot").LiteralSchema<"createAttachment", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                     readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                         readonly failed: import("valibot").BooleanSchema<undefined>;
                         readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -464,7 +485,7 @@ export declare const sync: {
                         readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                     }, undefined>;
-                    readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                     readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                     readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -500,6 +521,15 @@ export declare const sync: {
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
                 readonly name: import("valibot").LiteralSchema<"sendDraft", undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"setAliasId", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;

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

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

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

@@ -30,11 +30,20 @@ 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.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
-                    readonly primary: v.BooleanSchema<undefined>;
-                }, undefined>, undefined>;
+                readonly aliases: v.ObjectSchema<{
+                    readonly nonPrimary: 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.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                        readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly primary: v.BooleanSchema<undefined>;
+                    }, undefined>, undefined>;
+                    readonly primary: v.ObjectSchema<{
+                        readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                        readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly primary: 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.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
                 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/draft.d.ts

@@ -30,6 +30,7 @@ export declare const syncPullDraft: import("../../../../..").EndpointConfig<"/v1
             readonly key: v.StringSchema<undefined>;
             readonly op: v.LiteralSchema<"put", undefined>;
             readonly value: v.ObjectSchema<{
+                readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
                 readonly attachments: v.ArraySchema<v.ObjectSchema<{
                     readonly failed: v.BooleanSchema<undefined>;
                     readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -46,7 +47,7 @@ export declare const syncPullDraft: import("../../../../..").EndpointConfig<"/v1
                     readonly subject: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                 }, undefined>;
-                readonly emailAccountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly emailAccountId: v.OptionalSchema<v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;
                 readonly error: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
                 readonly referencedMessageId: v.NullableSchema<v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;

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

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

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

@@ -30,11 +30,20 @@ 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                        readonly primary: import("valibot").BooleanSchema<undefined>;
-                    }, undefined>, undefined>;
+                    readonly aliases: import("valibot").ObjectSchema<{
+                        readonly nonPrimary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly primary: import("valibot").BooleanSchema<undefined>;
+                        }, undefined>, undefined>;
+                        readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                     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>;
@@ -127,6 +136,7 @@ export declare const pull: {
                 readonly key: import("valibot").StringSchema<undefined>;
                 readonly op: import("valibot").LiteralSchema<"put", undefined>;
                 readonly value: import("valibot").ObjectSchema<{
+                    readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                     readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                         readonly failed: import("valibot").BooleanSchema<undefined>;
                         readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -143,7 +153,7 @@ export declare const pull: {
                         readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                     }, undefined>;
-                    readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                     readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                     readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;

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

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

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

@@ -17,6 +17,7 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
             readonly alias: v.ObjectSchema<{
                 readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
                 readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly primary: v.BooleanSchema<undefined>;
             }, undefined>;
         }, undefined>;
@@ -38,6 +39,15 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
         readonly name: v.LiteralSchema<"deleteAlias", undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly accountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+            readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+            readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"setAliasName", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly accountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiE1B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAuE1B,CAAA"}

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

@@ -30,6 +30,12 @@ export const syncPushAccount = createEndpoint({
                 id: v.number(),
                 name: v.literal('deleteAlias'),
             }),
+            setAliasName: v.object({
+                args: account.mutators.setAliasName.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('setAliasName'),
+            }),
             setAliasPrimary: v.object({
                 args: account.mutators.setAliasPrimary.delta,
                 clientID: v.string(),

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

@@ -28,6 +28,7 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
         readonly name: v.LiteralSchema<"createAttachment", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
+            readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
             readonly attachments: v.ArraySchema<v.ObjectSchema<{
                 readonly failed: v.BooleanSchema<undefined>;
                 readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -44,7 +45,7 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
                 readonly subject: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
             }, undefined>;
-            readonly emailAccountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+            readonly emailAccountId: v.OptionalSchema<v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;
             readonly error: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
             readonly referencedMessageId: v.NullableSchema<v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>, undefined>;
@@ -80,6 +81,15 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
         readonly name: v.LiteralSchema<"sendDraft", undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+            readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+            readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"setAliasId", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;

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

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

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

@@ -42,6 +42,12 @@ export const syncPushDraft = createEndpoint({
                 id: v.number(),
                 name: v.literal('sendDraft'),
             }),
+            setAliasId: v.object({
+                args: draft.mutators.setAliasId.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('setAliasId'),
+            }),
             setContent: v.object({
                 args: draft.mutators.setContent.delta,
                 clientID: v.string(),

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

@@ -17,6 +17,7 @@ export declare const push: {
                 readonly alias: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly primary: import("valibot").BooleanSchema<undefined>;
                 }, undefined>;
             }, undefined>;
@@ -38,6 +39,15 @@ export declare const push: {
             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 accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"setAliasName", undefined>;
         }, undefined> | import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
                 readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -158,6 +168,7 @@ export declare const push: {
             readonly name: import("valibot").LiteralSchema<"createAttachment", undefined>;
         }, undefined> | import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
+                readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                 readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                     readonly failed: import("valibot").BooleanSchema<undefined>;
                     readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -174,7 +185,7 @@ export declare const push: {
                     readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                 }, undefined>;
-                readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                 readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                 readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                 readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -210,6 +221,15 @@ export declare const push: {
             readonly clientID: import("valibot").StringSchema<undefined>;
             readonly id: import("valibot").NumberSchema<undefined>;
             readonly name: import("valibot").LiteralSchema<"sendDraft", undefined>;
+        }, undefined> | import("valibot").ObjectSchema<{
+            readonly args: import("valibot").ObjectSchema<{
+                readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+            }, undefined>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"setAliasId", undefined>;
         }, undefined> | import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
                 readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;

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

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

package/dist/sdk/index.d.ts

@@ -99,11 +99,20 @@ 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                                        readonly primary: import("valibot").BooleanSchema<undefined>;
-                                    }, undefined>, undefined>;
+                                    readonly aliases: import("valibot").ObjectSchema<{
+                                        readonly nonPrimary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                            readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                            readonly primary: import("valibot").BooleanSchema<undefined>;
+                                        }, undefined>, undefined>;
+                                        readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                            readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                            readonly primary: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                     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>;
@@ -196,6 +205,7 @@ export declare const marcoSDK: {
                                 readonly key: import("valibot").StringSchema<undefined>;
                                 readonly op: import("valibot").LiteralSchema<"put", undefined>;
                                 readonly value: import("valibot").ObjectSchema<{
+                                    readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                     readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                         readonly failed: import("valibot").BooleanSchema<undefined>;
                                         readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -212,7 +222,7 @@ export declare const marcoSDK: {
                                         readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                         readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                                     }, undefined>;
-                                    readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                    readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                                     readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                     readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -375,6 +385,7 @@ export declare const marcoSDK: {
                                 readonly alias: 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").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                    readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly primary: import("valibot").BooleanSchema<undefined>;
                                 }, undefined>;
                             }, undefined>;
@@ -396,6 +407,15 @@ export declare const marcoSDK: {
                             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 accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            }, undefined>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"setAliasName", undefined>;
                         }, undefined> | import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
                                 readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -516,6 +536,7 @@ export declare const marcoSDK: {
                             readonly name: import("valibot").LiteralSchema<"createAttachment", undefined>;
                         }, undefined> | import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
+                                readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                 readonly attachments: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                                     readonly failed: import("valibot").BooleanSchema<undefined>;
                                     readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -532,7 +553,7 @@ export declare const marcoSDK: {
                                     readonly subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
                                 }, undefined>;
-                                readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly emailAccountId: import("valibot").OptionalSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
                                 readonly error: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                                 readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                 readonly referencedMessageId: import("valibot").NullableSchema<import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>, undefined>;
@@ -568,6 +589,15 @@ export declare const marcoSDK: {
                             readonly clientID: import("valibot").StringSchema<undefined>;
                             readonly id: import("valibot").NumberSchema<undefined>;
                             readonly name: import("valibot").LiteralSchema<"sendDraft", undefined>;
+                        }, undefined> | import("valibot").ObjectSchema<{
+                            readonly args: import("valibot").ObjectSchema<{
+                                readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                            }, undefined>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"setAliasId", undefined>;
                         }, undefined> | import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
                                 readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;

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

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

package/package.json

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