@marcoappio/marco-config 2.0.340 → 2.0.342

package/dist/clients/account.d.ts

@@ -21,7 +21,6 @@ export declare const account: {
                 readonly processed: v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
                 readonly total: v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
             }, undefined>;
-            readonly name: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly path: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly specialUse: v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"ARCHIVE", undefined>, v.LiteralSchema<"INBOX", undefined>, v.LiteralSchema<"SENT", undefined>, v.LiteralSchema<"SPAM", undefined>, v.LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
         }, undefined>, undefined>;
@@ -49,6 +48,12 @@ export declare const account: {
                 }, undefined>;
             }, undefined>;
         };
+        createLabel: {
+            delta: v.ObjectSchema<{
+                readonly accountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly path: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
         deleteAccount: {
             delta: v.ObjectSchema<{
                 readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
@@ -60,6 +65,11 @@ export declare const account: {
                 readonly aliasId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
             }, undefined>;
         };
+        deleteLabel: {
+            delta: v.ObjectSchema<{
+                readonly labelId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
         setAliasName: {
             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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFG,CAAA"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8FG,CAAA"}

package/dist/clients/account.js

@@ -23,7 +23,6 @@ export const account = {
                 processed: v.pipe(v.number(), v.minValue(0)),
                 total: v.pipe(v.number(), v.minValue(0)),
             }),
-            name: marcoSchemas.string.required(),
             path: marcoSchemas.string.required(),
             specialUse: v.nullable(marcoSchemas.labels.specialUse()),
         })),
@@ -44,6 +43,12 @@ export const account = {
                 alias: aliasSchema,
             }),
         },
+        createLabel: {
+            delta: v.object({
+                accountId: marcoSchemas.string.shortUUID(),
+                path: marcoSchemas.string.required(),
+            }),
+        },
         deleteAccount: {
             delta: v.object({
                 id: marcoSchemas.string.shortUUID(),
@@ -55,6 +60,11 @@ export const account = {
                 aliasId: marcoSchemas.string.shortUUID(),
             }),
         },
+        deleteLabel: {
+            delta: v.object({
+                labelId: marcoSchemas.string.required(),
+            }),
+        },
         setAliasName: {
             delta: v.object({
                 accountId: marcoSchemas.string.shortUUID(),

package/dist/clients/index.d.ts

@@ -22,7 +22,6 @@ export declare const marcoClients: {
                     readonly processed: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                     readonly total: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                 }, undefined>;
-                readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
             }, undefined>, undefined>;
@@ -50,6 +49,12 @@ export declare const marcoClients: {
                     }, undefined>;
                 }, undefined>;
             };
+            createLabel: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+            };
             deleteAccount: {
                 delta: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -61,6 +66,11 @@ export declare const marcoClients: {
                     readonly aliasId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                 }, undefined>;
             };
+            deleteLabel: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly labelId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+            };
             setAliasName: {
                 delta: import("valibot").ObjectSchema<{
                     readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -444,6 +454,13 @@ export declare const marcoClients: {
             readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
             readonly settings: import("valibot").ObjectSchema<{
                 readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly notifications: import("valibot").ObjectSchema<{
+                    readonly pushNotificationTokens: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                        readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                        readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    }, undefined>, undefined>;
+                }, undefined>;
             }, undefined>;
         }, undefined>;
         mutators: {
@@ -453,6 +470,16 @@ export declare const marcoClients: {
                     readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 }, undefined>;
             };
+            setSettingsPushNotificationToken: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly pushNotificationToken: import("valibot").ObjectSchema<{
+                        readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                        readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+            };
         };
         name: "user";
         pullUrl: "/v1/pv/sync/pull/user";

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

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

package/dist/clients/user.d.ts

@@ -4,6 +4,13 @@ export declare const user: {
         readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
         readonly settings: v.ObjectSchema<{
             readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly notifications: v.ObjectSchema<{
+                readonly pushNotificationTokens: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+                    readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly deviceId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly token: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
         }, undefined>;
     }, undefined>;
     mutators: {
@@ -13,6 +20,16 @@ export declare const user: {
                 readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             }, undefined>;
         };
+        setSettingsPushNotificationToken: {
+            delta: v.ObjectSchema<{
+                readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+                readonly pushNotificationToken: v.ObjectSchema<{
+                    readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly deviceId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly token: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+            }, undefined>;
+        };
     };
     name: "user";
     pullUrl: "/v1/pv/sync/pull/user";

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

@@ -1 +1 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/clients/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAS5B,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;CAiBM,CAAA"}
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/clients/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAuB5B,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBM,CAAA"}

package/dist/clients/user.js

@@ -1,7 +1,16 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../schemas';
+const pushNotificationToken = v.object({
+    createdAt: marcoSchemas.number.positiveInteger(),
+    deviceId: marcoSchemas.string.required(),
+    token: marcoSchemas.string.required(),
+});
+const pushNotificationTokens = v.record(marcoSchemas.string.required(), pushNotificationToken);
 const userSettings = v.object({
     name: marcoSchemas.string.nullable(),
+    notifications: v.object({
+        pushNotificationTokens,
+    }),
 });
 export const user = {
     model: v.object({
@@ -15,6 +24,12 @@ export const user = {
                 name: marcoSchemas.string.nullable(),
             }),
         },
+        setSettingsPushNotificationToken: {
+            delta: v.object({
+                id: marcoSchemas.string.shortUUID(),
+                pushNotificationToken,
+            }),
+        },
     },
     name: 'user',
     pullUrl: '/v1/pv/sync/pull/user',

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

@@ -87,7 +87,6 @@ export declare const endpoints: {
                                         readonly processed: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                                         readonly total: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                                     }, undefined>;
-                                    readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                     readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
                                 }, undefined>, undefined>;
@@ -325,6 +324,13 @@ export declare const endpoints: {
                                 readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                 readonly settings: import("valibot").ObjectSchema<{
                                     readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    readonly notifications: import("valibot").ObjectSchema<{
+                                        readonly pushNotificationTokens: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                                            readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                                            readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                            readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                        }, undefined>, undefined>;
+                                    }, undefined>;
                                 }, undefined>;
                             }, undefined>;
                         }, undefined>], undefined>, undefined>;
@@ -357,6 +363,14 @@ export declare const endpoints: {
                         readonly clientID: import("valibot").StringSchema<undefined>;
                         readonly id: import("valibot").NumberSchema<undefined>;
                         readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
+                    }, undefined> | import("valibot").ObjectSchema<{
+                        readonly args: import("valibot").ObjectSchema<{
+                            readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"createLabel", undefined>;
                     }, undefined> | import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
                             readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -372,6 +386,13 @@ 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 labelId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"deleteLabel", undefined>;
                     }, undefined> | import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
                             readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -773,7 +794,7 @@ export declare const endpoints: {
                 }, undefined>], undefined>>;
                 user: EndpointConfig<"/v1/pv/sync/push/user", import("valibot").ObjectSchema<{
                     readonly clientGroupID: import("valibot").StringSchema<undefined>;
-                    readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<import("valibot").ObjectSchema<{
+                    readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
                             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").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -781,7 +802,19 @@ export declare const endpoints: {
                         readonly clientID: import("valibot").StringSchema<undefined>;
                         readonly id: import("valibot").NumberSchema<undefined>;
                         readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
-                    }, undefined>[], undefined>, undefined>;
+                    }, undefined> | import("valibot").ObjectSchema<{
+                        readonly args: import("valibot").ObjectSchema<{
+                            readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                            readonly pushNotificationToken: import("valibot").ObjectSchema<{
+                                readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                                readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
+                        readonly clientID: import("valibot").StringSchema<undefined>;
+                        readonly id: import("valibot").NumberSchema<undefined>;
+                        readonly name: import("valibot").LiteralSchema<"setSettingsPushNotificationToken", undefined>;
+                    }, undefined>)[], undefined>, undefined>;
                 }, undefined>, GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
                         readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", 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

@@ -84,7 +84,6 @@ export declare const privateGroup: {
                                     readonly processed: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                                     readonly total: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                                 }, undefined>;
-                                readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                 readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
                             }, undefined>, undefined>;
@@ -322,6 +321,13 @@ export declare const privateGroup: {
                             readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                             readonly settings: import("valibot").ObjectSchema<{
                                 readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly notifications: import("valibot").ObjectSchema<{
+                                    readonly pushNotificationTokens: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                                        readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                                        readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                        readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    }, undefined>, undefined>;
+                                }, undefined>;
                             }, undefined>;
                         }, undefined>;
                     }, undefined>], undefined>, undefined>;
@@ -354,6 +360,14 @@ export declare const privateGroup: {
                     readonly clientID: import("valibot").StringSchema<undefined>;
                     readonly id: import("valibot").NumberSchema<undefined>;
                     readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
+                }, undefined> | import("valibot").ObjectSchema<{
+                    readonly args: import("valibot").ObjectSchema<{
+                        readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"createLabel", undefined>;
                 }, undefined> | import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
                         readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -369,6 +383,13 @@ 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 labelId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"deleteLabel", undefined>;
                 }, undefined> | import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
                         readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -770,7 +791,7 @@ export declare const privateGroup: {
             }, undefined>], undefined>>;
             user: import("../../..").EndpointConfig<"/v1/pv/sync/push/user", import("valibot").ObjectSchema<{
                 readonly clientGroupID: import("valibot").StringSchema<undefined>;
-                readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<import("valibot").ObjectSchema<{
+                readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
                         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").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -778,7 +799,19 @@ export declare const privateGroup: {
                     readonly clientID: import("valibot").StringSchema<undefined>;
                     readonly id: import("valibot").NumberSchema<undefined>;
                     readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
-                }, undefined>[], undefined>, undefined>;
+                }, undefined> | import("valibot").ObjectSchema<{
+                    readonly args: import("valibot").ObjectSchema<{
+                        readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                        readonly pushNotificationToken: import("valibot").ObjectSchema<{
+                            readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                            readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"setSettingsPushNotificationToken", undefined>;
+                }, undefined>)[], undefined>, undefined>;
             }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", 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":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIxB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sdk/endpoints/private/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIxB,CAAA"}

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

@@ -51,7 +51,6 @@ export declare const sync: {
                                 readonly processed: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                                 readonly total: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                             }, undefined>;
-                            readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
                         }, undefined>, undefined>;
@@ -289,6 +288,13 @@ export declare const sync: {
                         readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                         readonly settings: import("valibot").ObjectSchema<{
                             readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly notifications: import("valibot").ObjectSchema<{
+                                readonly pushNotificationTokens: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                                    readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                                    readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                }, undefined>, undefined>;
+                            }, undefined>;
                         }, undefined>;
                     }, undefined>;
                 }, undefined>], undefined>, undefined>;
@@ -321,6 +327,14 @@ export declare const sync: {
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
                 readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"createLabel", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -336,6 +350,13 @@ 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 labelId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"deleteLabel", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -737,7 +758,7 @@ export declare const sync: {
         }, undefined>], undefined>>;
         user: import("../../../..").EndpointConfig<"/v1/pv/sync/push/user", import("valibot").ObjectSchema<{
             readonly clientGroupID: import("valibot").StringSchema<undefined>;
-            readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<import("valibot").ObjectSchema<{
+            readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     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").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -745,7 +766,19 @@ export declare const sync: {
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
                 readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
-            }, undefined>[], undefined>, undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
+                readonly args: import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                    readonly pushNotificationToken: import("valibot").ObjectSchema<{
+                        readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                        readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"setSettingsPushNotificationToken", undefined>;
+            }, undefined>)[], undefined>, undefined>;
         }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", 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

@@ -50,7 +50,6 @@ export declare const syncPullAccount: import("../../../../..").EndpointConfig<"/
                         readonly processed: v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
                         readonly total: v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
                     }, undefined>;
-                    readonly name: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly path: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
                     readonly specialUse: v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"ARCHIVE", undefined>, v.LiteralSchema<"INBOX", undefined>, v.LiteralSchema<"SENT", undefined>, v.LiteralSchema<"SPAM", undefined>, v.LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
                 }, undefined>, undefined>;

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

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

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

@@ -50,7 +50,6 @@ export declare const pull: {
                             readonly processed: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                             readonly total: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                         }, undefined>;
-                        readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
                     }, undefined>, undefined>;
@@ -288,6 +287,13 @@ export declare const pull: {
                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                     readonly settings: import("valibot").ObjectSchema<{
                         readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly notifications: import("valibot").ObjectSchema<{
+                            readonly pushNotificationTokens: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                                readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                                readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            }, undefined>, undefined>;
+                        }, undefined>;
                     }, undefined>;
                 }, undefined>;
             }, undefined>], undefined>, undefined>;

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

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

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

@@ -33,6 +33,13 @@ export declare const syncPullUser: import("../../../../..").EndpointConfig<"/v1/
                 readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
                 readonly settings: v.ObjectSchema<{
                     readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly notifications: v.ObjectSchema<{
+                        readonly pushNotificationTokens: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+                            readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                            readonly deviceId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly token: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                        }, undefined>, undefined>;
+                    }, undefined>;
                 }, undefined>;
             }, undefined>;
         }, undefined>], undefined>, undefined>;

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

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

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

@@ -23,6 +23,14 @@ export declare const syncPushAccount: import("../../../../..").EndpointConfig<"/
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
         readonly name: v.LiteralSchema<"createAlias", undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly accountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+            readonly path: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"createLabel", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
@@ -38,6 +46,13 @@ 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 labelId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"deleteLabel", 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAwE1B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoF1B,CAAA"}

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

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

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

@@ -23,6 +23,14 @@ export declare const push: {
             readonly clientID: import("valibot").StringSchema<undefined>;
             readonly id: import("valibot").NumberSchema<undefined>;
             readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
+        }, undefined> | import("valibot").ObjectSchema<{
+            readonly args: import("valibot").ObjectSchema<{
+                readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"createLabel", undefined>;
         }, undefined> | import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
                 readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -38,6 +46,13 @@ 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 labelId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"deleteLabel", undefined>;
         }, undefined> | import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
                 readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -439,7 +454,7 @@ export declare const push: {
     }, undefined>], undefined>>;
     user: import("../../../../..").EndpointConfig<"/v1/pv/sync/push/user", import("valibot").ObjectSchema<{
         readonly clientGroupID: import("valibot").StringSchema<undefined>;
-        readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<import("valibot").ObjectSchema<{
+        readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
                 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").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -447,7 +462,19 @@ export declare const push: {
             readonly clientID: import("valibot").StringSchema<undefined>;
             readonly id: import("valibot").NumberSchema<undefined>;
             readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
-        }, undefined>[], undefined>, undefined>;
+        }, undefined> | import("valibot").ObjectSchema<{
+            readonly args: import("valibot").ObjectSchema<{
+                readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                readonly pushNotificationToken: import("valibot").ObjectSchema<{
+                    readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+            }, undefined>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"setSettingsPushNotificationToken", undefined>;
+        }, undefined>)[], undefined>, undefined>;
     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
         readonly data: import("valibot").ObjectSchema<{
             readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", 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/endpoints/private/sync/push/user.d.ts

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 export declare const syncPushUser: import("../../../../..").EndpointConfig<"/v1/pv/sync/push/user", v.ObjectSchema<{
     readonly clientGroupID: v.StringSchema<undefined>;
-    readonly mutations: v.ArraySchema<v.UnionSchema<v.ObjectSchema<{
+    readonly mutations: v.ArraySchema<v.UnionSchema<(v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
             readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -9,7 +9,19 @@ export declare const syncPushUser: import("../../../../..").EndpointConfig<"/v1/
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
         readonly name: v.LiteralSchema<"setSettingsName", undefined>;
-    }, undefined>[], undefined>, undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: v.ObjectSchema<{
+            readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+            readonly pushNotificationToken: v.ObjectSchema<{
+                readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly deviceId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly token: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly clientID: v.StringSchema<undefined>;
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.LiteralSchema<"setSettingsPushNotificationToken", undefined>;
+    }, undefined>)[], undefined>, undefined>;
 }, undefined>, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.UnionSchema<[v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;

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

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

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

@@ -12,6 +12,12 @@ export const syncPushUser = createEndpoint({
                 id: v.number(),
                 name: v.literal('setSettingsName'),
             }),
+            setSettingsPushNotificationToken: v.object({
+                args: user.mutators.setSettingsPushNotificationToken.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('setSettingsPushNotificationToken'),
+            }),
         }))),
     }),
     method: 'POST',

package/dist/sdk/index.d.ts

@@ -86,7 +86,6 @@ export declare const marcoSDK: {
                                             readonly processed: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                                             readonly total: import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
                                         }, undefined>;
-                                        readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                         readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                                         readonly specialUse: import("valibot").NullableSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ARCHIVE", undefined>, import("valibot").LiteralSchema<"INBOX", undefined>, import("valibot").LiteralSchema<"SENT", undefined>, import("valibot").LiteralSchema<"SPAM", undefined>, import("valibot").LiteralSchema<"TRASH", undefined>], undefined>, undefined>;
                                     }, undefined>, undefined>;
@@ -324,6 +323,13 @@ export declare const marcoSDK: {
                                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                                     readonly settings: import("valibot").ObjectSchema<{
                                         readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                        readonly notifications: import("valibot").ObjectSchema<{
+                                            readonly pushNotificationTokens: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                                                readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                                                readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                                readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                            }, undefined>, undefined>;
+                                        }, undefined>;
                                     }, undefined>;
                                 }, undefined>;
                             }, undefined>], undefined>, undefined>;
@@ -356,6 +362,14 @@ export declare const marcoSDK: {
                             readonly clientID: import("valibot").StringSchema<undefined>;
                             readonly id: import("valibot").NumberSchema<undefined>;
                             readonly name: import("valibot").LiteralSchema<"createAlias", undefined>;
+                        }, undefined> | import("valibot").ObjectSchema<{
+                            readonly args: import("valibot").ObjectSchema<{
+                                readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"createLabel", undefined>;
                         }, undefined> | import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
                                 readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -371,6 +385,13 @@ 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 labelId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, 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<"deleteLabel", undefined>;
                         }, undefined> | import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
                                 readonly accountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
@@ -772,7 +793,7 @@ export declare const marcoSDK: {
                     }, undefined>], undefined>>;
                     user: import("..").EndpointConfig<"/v1/pv/sync/push/user", import("valibot").ObjectSchema<{
                         readonly clientGroupID: import("valibot").StringSchema<undefined>;
-                        readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<import("valibot").ObjectSchema<{
+                        readonly mutations: import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
                                 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").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -780,7 +801,19 @@ export declare const marcoSDK: {
                             readonly clientID: import("valibot").StringSchema<undefined>;
                             readonly id: import("valibot").NumberSchema<undefined>;
                             readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
-                        }, undefined>[], undefined>, undefined>;
+                        }, undefined> | import("valibot").ObjectSchema<{
+                            readonly args: import("valibot").ObjectSchema<{
+                                readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+                                readonly pushNotificationToken: import("valibot").ObjectSchema<{
+                                    readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                                    readonly deviceId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                    readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                }, undefined>;
+                            }, undefined>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"setSettingsPushNotificationToken", undefined>;
+                        }, undefined>)[], undefined>, undefined>;
                     }, undefined>, import("valibot").GenericSchema<unknown, unknown, import("valibot").BaseIssue<unknown>> | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                         readonly data: import("valibot").ObjectSchema<{
                             readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", 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/dist/utils/accounts/index.d.ts

@@ -1,4 +1,8 @@
 export declare const accountUtils: {
     generateColor: (emailAddress: string) => string;
+    labelIdGenerate: (params: {
+        accountId: string;
+        path: string;
+    }) => string;
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/accounts/index.d.ts.map

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

package/dist/utils/accounts/index.js

@@ -1,4 +1,6 @@
 import { generateAccountColor } from './generateAccountColor';
+import { labelIdGenerate } from './labelIdGenerate';
 export const accountUtils = {
     generateColor: generateAccountColor,
+    labelIdGenerate,
 };

package/dist/utils/accounts/labelIdGenerate.d.ts

@@ -0,0 +1,5 @@
+export declare const labelIdGenerate: (params: {
+    accountId: string;
+    path: string;
+}) => string;
+//# sourceMappingURL=labelIdGenerate.d.ts.map

package/dist/utils/accounts/labelIdGenerate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labelIdGenerate.d.ts","sourceRoot":"","sources":["../../../src/utils/accounts/labelIdGenerate.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,WAAY;IACpC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;CACf,WAOA,CAAA"}

package/dist/utils/accounts/labelIdGenerate.js

@@ -0,0 +1,6 @@
+import { v5 as uuidv5 } from 'uuid';
+import { shortUUID } from '../../utils';
+export const labelIdGenerate = (params) => {
+    const val = uuidv5(JSON.stringify([params.accountId, params.path]), uuidv5.URL);
+    return shortUUID.fromUUID(val);
+};

package/dist/utils/accounts/labelIdGenerate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=labelIdGenerate.test.d.ts.map

package/dist/utils/accounts/labelIdGenerate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labelIdGenerate.test.d.ts","sourceRoot":"","sources":["../../../src/utils/accounts/labelIdGenerate.test.ts"],"names":[],"mappings":""}

package/dist/utils/accounts/labelIdGenerate.test.js

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'bun:test';
+import { labelIdGenerate } from './labelIdGenerate';
+describe('labelIdGenerate', () => {
+    const accountId1 = 'account-uuid-1';
+    const accountId2 = 'account-uuid-2';
+    const path1 = '/inbox';
+    const path2 = '/sent';
+    it('should generate different IDs for different paths with same accountId', () => {
+        const id1 = labelIdGenerate({ accountId: accountId1, path: path1 });
+        const id2 = labelIdGenerate({ accountId: accountId1, path: path2 });
+        expect(id1).not.toBe(id2);
+        expect(typeof id1).toBe('string');
+        expect(typeof id2).toBe('string');
+        expect(id1.length).toBeGreaterThan(0);
+        expect(id2.length).toBeGreaterThan(0);
+    });
+    it('should generate different IDs for different accountIds with same path', () => {
+        const id1 = labelIdGenerate({ accountId: accountId1, path: path1 });
+        const id2 = labelIdGenerate({ accountId: accountId2, path: path1 });
+        expect(id1).not.toBe(id2);
+        expect(typeof id1).toBe('string');
+        expect(typeof id2).toBe('string');
+        expect(id1.length).toBeGreaterThan(0);
+        expect(id2.length).toBeGreaterThan(0);
+    });
+    it('should generate different IDs for different accountIds and different paths', () => {
+        const id1 = labelIdGenerate({ accountId: accountId1, path: path1 });
+        const id2 = labelIdGenerate({ accountId: accountId2, path: path2 });
+        expect(id1).not.toBe(id2);
+        expect(typeof id1).toBe('string');
+        expect(typeof id2).toBe('string');
+        expect(id1.length).toBeGreaterThan(0);
+        expect(id2.length).toBeGreaterThan(0);
+    });
+    it('should generate the same ID for identical inputs (deterministic)', () => {
+        const id1 = labelIdGenerate({ accountId: accountId1, path: path1 });
+        const id2 = labelIdGenerate({ accountId: accountId1, path: path1 });
+        expect(id1).toBe(id2);
+    });
+    it('should handle empty strings', () => {
+        const id1 = labelIdGenerate({ accountId: '', path: '' });
+        const id2 = labelIdGenerate({ accountId: 'test', path: '' });
+        const id3 = labelIdGenerate({ accountId: '', path: 'test' });
+        expect(id1).not.toBe(id2);
+        expect(id1).not.toBe(id3);
+        expect(id2).not.toBe(id3);
+        expect(typeof id1).toBe('string');
+        expect(typeof id2).toBe('string');
+        expect(typeof id3).toBe('string');
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@marcoappio/marco-config",
   "packageManager": "bun@1.2.0",
-  "version": "2.0.340",
+  "version": "2.0.342",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",
@@ -34,6 +34,7 @@
     "eslint-plugin-sort-keys-fix": "1.1.2",
     "eslint-plugin-typescript-sort-keys": "2.3.0",
     "short-uuid": "5.2.0",
+    "uuid": "11.1.0",
     "valibot": "1.0.0-beta.9"
   },
   "devDependencies": {