@marcoappio/marco-config 2.0.327 → 2.0.329

package/dist/clients/draft.d.ts

@@ -109,13 +109,6 @@ export declare const draft: {
                 readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
             }, undefined>;
         };
-        setEmailAccountId: {
-            delta: v.ObjectSchema<{
-                readonly emailAccountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
-                readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
-                readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            }, undefined>;
-        };
         setEnvelope: {
             delta: v.ObjectSchema<{
                 readonly envelope: Omit<v.ObjectSchema<{

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

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

package/dist/clients/draft.js

@@ -86,14 +86,6 @@ export const draft = {
                 updatedAt: marcoSchemas.number.positiveInteger(),
             }),
         },
-        // Deprecated
-        setEmailAccountId: {
-            delta: v.object({
-                emailAccountId: marcoSchemas.string.shortUUID(),
-                id: marcoSchemas.string.shortUUID(),
-                updatedAt: marcoSchemas.number.positiveInteger(),
-            }),
-        },
         setEnvelope: {
             delta: v.object({
                 envelope: v.omit(bodySchema, ['content']),

package/dist/clients/index.d.ts

@@ -261,13 +261,6 @@ export declare const marcoClients: {
                     readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
                 }, undefined>;
             };
-            setEmailAccountId: {
-                delta: import("valibot").ObjectSchema<{
-                    readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                    readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                    readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                }, undefined>;
-            };
             setEnvelope: {
                 delta: import("valibot").ObjectSchema<{
                     readonly envelope: Omit<import("valibot").ObjectSchema<{
@@ -449,36 +442,28 @@ 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").ObjectSchema<Record<"ios" | "osx" | "web", 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>;
         mutators: {
-            setSettings: {
+            setSettingsName: {
                 delta: import("valibot").ObjectSchema<{
-                    readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                    readonly settings: Omit<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>;
-                    }, undefined>, "~standard" | "~run" | "~types" | "entries"> & {
-                        readonly entries: {
-                            readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                        };
-                        readonly '~standard': import("valibot").StandardSchemaProps<{
-                            name?: string | null | undefined;
-                        }, {
-                            name?: string | null | undefined;
-                        }>;
-                        readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                            name?: string | null | undefined;
-                        }, import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue>;
-                        readonly '~types'?: {
-                            readonly input: {
-                                name?: string | null | undefined;
-                            };
-                            readonly output: {
-                                name?: string | null | undefined;
-                            };
-                            readonly issue: import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue;
-                        } | 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>;
+                }, undefined>;
+            };
+            setSettingsPushNotifactionToken: {
+                delta: 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>;
             };
         };

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,36 +4,28 @@ 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.ObjectSchema<Record<"ios" | "osx" | "web", 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 platform: v.UnionSchema<[v.LiteralSchema<"ios", undefined>, v.LiteralSchema<"osx", undefined>, v.LiteralSchema<"web", 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>;
     mutators: {
-        setSettings: {
+        setSettingsName: {
+            delta: v.ObjectSchema<{
+                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        };
+        setSettingsPushNotifactionToken: {
             delta: v.ObjectSchema<{
-                readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
-                readonly settings: Omit<v.ObjectSchema<{
-                    readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                }, undefined>, "~standard" | "~run" | "~types" | "entries"> & {
-                    readonly entries: {
-                        readonly name: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                    };
-                    readonly '~standard': v.StandardSchemaProps<{
-                        name?: string | null | undefined;
-                    }, {
-                        name?: string | null | undefined;
-                    }>;
-                    readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
-                        name?: string | null | undefined;
-                    }, v.StringIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.ObjectIssue>;
-                    readonly '~types'?: {
-                        readonly input: {
-                            name?: string | null | undefined;
-                        };
-                        readonly output: {
-                            name?: string | null | undefined;
-                        };
-                        readonly issue: v.StringIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.ObjectIssue;
-                    } | undefined;
-                };
+                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 platform: v.UnionSchema<[v.LiteralSchema<"ios", undefined>, v.LiteralSchema<"osx", undefined>, v.LiteralSchema<"web", undefined>], undefined>;
+                readonly token: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             }, undefined>;
         };
     };

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;AA6B5B,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBM,CAAA"}

package/dist/clients/user.js

@@ -1,7 +1,17 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../schemas';
+const pushNotificationToken = v.object({
+    createdAt: marcoSchemas.number.positiveInteger(),
+    deviceId: marcoSchemas.string.required(),
+    platform: marcoSchemas.app.platform(),
+    token: marcoSchemas.string.required(),
+});
+const pushNotificationTokens = v.object(v.entriesFromList(marcoSchemas.app.platform().options.map(x => x.literal), v.record(marcoSchemas.string.required(), pushNotificationToken)));
 const userSettings = v.object({
     name: marcoSchemas.string.nullable(),
+    notifications: v.object({
+        pushNotificationTokens,
+    }),
 });
 export const user = {
     model: v.object({
@@ -9,12 +19,14 @@ export const user = {
         settings: userSettings,
     }),
     mutators: {
-        setSettings: {
+        setSettingsName: {
             delta: v.object({
-                id: marcoSchemas.string.shortUUID(),
-                settings: v.partial(userSettings),
+                name: marcoSchemas.string.nullable(),
             }),
         },
+        setSettingsPushNotifactionToken: {
+            delta: pushNotificationToken,
+        },
     },
     name: 'user',
     pullUrl: '/v1/pv/sync/pull/user',

package/dist/schemas/index.d.ts

@@ -1,5 +1,8 @@
 import * as v from 'valibot';
 export declare const marcoSchemas: {
+    app: {
+        platform: () => v.UnionSchema<[v.LiteralSchema<"ios", undefined>, v.LiteralSchema<"osx", undefined>, v.LiteralSchema<"web", undefined>], undefined>;
+    };
     drafts: {
         contentPatch: {
             instruction: () => v.ObjectSchema<{

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAsCP,MAAM,OAAO,MAAM;;;;;;;;;;;;;;;;CAYpC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA6CP,MAAM,OAAO,MAAM;;;;;;;;;;;;;;;;CAYpC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA"}

package/dist/schemas/index.js

@@ -9,6 +9,13 @@ const patchInstructionSchema = v.object({
     value: v.string(),
 });
 export const marcoSchemas = {
+    app: {
+        platform: () => v.union([
+            v.literal('ios'),
+            v.literal('osx'),
+            v.literal('web'),
+        ]),
+    },
     drafts: {
         contentPatch: {
             instruction: () => patchInstructionSchema,

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

@@ -326,6 +326,14 @@ 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").ObjectSchema<Record<"ios" | "osx" | "web", 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>, undefined>;
@@ -569,15 +577,6 @@ export declare const endpoints: {
                         readonly clientID: import("valibot").StringSchema<undefined>;
                         readonly id: import("valibot").NumberSchema<undefined>;
                         readonly name: import("valibot").LiteralSchema<"setContent", undefined>;
-                    }, undefined> | import("valibot").ObjectSchema<{
-                        readonly args: import("valibot").ObjectSchema<{
-                            readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                            readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                            readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                        }, undefined>;
-                        readonly clientID: import("valibot").StringSchema<undefined>;
-                        readonly id: import("valibot").NumberSchema<undefined>;
-                        readonly name: import("valibot").LiteralSchema<"setEmailAccountId", undefined>;
                     }, undefined> | import("valibot").ObjectSchema<{
                         readonly args: import("valibot").ObjectSchema<{
                             readonly envelope: Omit<import("valibot").ObjectSchema<{
@@ -765,38 +764,24 @@ 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 settings: Omit<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>;
-                            }, undefined>, "~standard" | "~run" | "~types" | "entries"> & {
-                                readonly entries: {
-                                    readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                                };
-                                readonly '~standard': import("valibot").StandardSchemaProps<{
-                                    name?: string | null | undefined;
-                                }, {
-                                    name?: string | null | undefined;
-                                }>;
-                                readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                                    name?: string | null | undefined;
-                                }, import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue>;
-                                readonly '~types'?: {
-                                    readonly input: {
-                                        name?: string | null | undefined;
-                                    };
-                                    readonly output: {
-                                        name?: string | null | undefined;
-                                    };
-                                    readonly issue: import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue;
-                                } | 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>;
                         }, undefined>;
                         readonly clientID: import("valibot").StringSchema<undefined>;
                         readonly id: import("valibot").NumberSchema<undefined>;
-                        readonly name: import("valibot").LiteralSchema<"setSettings", undefined>;
-                    }, undefined>[], undefined>, undefined>;
+                        readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
+                    }, undefined> | import("valibot").ObjectSchema<{
+                        readonly args: 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>;
+                        readonly clientID: import("valibot").StringSchema<undefined>;
+                        readonly id: import("valibot").NumberSchema<undefined>;
+                        readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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

@@ -323,6 +323,14 @@ 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").ObjectSchema<Record<"ios" | "osx" | "web", 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>, undefined>;
@@ -566,15 +574,6 @@ export declare const privateGroup: {
                     readonly clientID: import("valibot").StringSchema<undefined>;
                     readonly id: import("valibot").NumberSchema<undefined>;
                     readonly name: import("valibot").LiteralSchema<"setContent", undefined>;
-                }, undefined> | import("valibot").ObjectSchema<{
-                    readonly args: import("valibot").ObjectSchema<{
-                        readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                        readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                        readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                    }, undefined>;
-                    readonly clientID: import("valibot").StringSchema<undefined>;
-                    readonly id: import("valibot").NumberSchema<undefined>;
-                    readonly name: import("valibot").LiteralSchema<"setEmailAccountId", undefined>;
                 }, undefined> | import("valibot").ObjectSchema<{
                     readonly args: import("valibot").ObjectSchema<{
                         readonly envelope: Omit<import("valibot").ObjectSchema<{
@@ -762,38 +761,24 @@ 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 settings: Omit<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>;
-                        }, undefined>, "~standard" | "~run" | "~types" | "entries"> & {
-                            readonly entries: {
-                                readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                            };
-                            readonly '~standard': import("valibot").StandardSchemaProps<{
-                                name?: string | null | undefined;
-                            }, {
-                                name?: string | null | undefined;
-                            }>;
-                            readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                                name?: string | null | undefined;
-                            }, import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue>;
-                            readonly '~types'?: {
-                                readonly input: {
-                                    name?: string | null | undefined;
-                                };
-                                readonly output: {
-                                    name?: string | null | undefined;
-                                };
-                                readonly issue: import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue;
-                            } | 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>;
                     }, undefined>;
                     readonly clientID: import("valibot").StringSchema<undefined>;
                     readonly id: import("valibot").NumberSchema<undefined>;
-                    readonly name: import("valibot").LiteralSchema<"setSettings", undefined>;
-                }, undefined>[], undefined>, undefined>;
+                    readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
+                }, undefined> | import("valibot").ObjectSchema<{
+                    readonly args: 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>;
+                    readonly clientID: import("valibot").StringSchema<undefined>;
+                    readonly id: import("valibot").NumberSchema<undefined>;
+                    readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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

@@ -290,6 +290,14 @@ 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").ObjectSchema<Record<"ios" | "osx" | "web", 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>, undefined>;
@@ -533,15 +541,6 @@ export declare const sync: {
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
                 readonly name: import("valibot").LiteralSchema<"setContent", undefined>;
-            }, undefined> | import("valibot").ObjectSchema<{
-                readonly args: import("valibot").ObjectSchema<{
-                    readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                    readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                    readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                }, undefined>;
-                readonly clientID: import("valibot").StringSchema<undefined>;
-                readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"setEmailAccountId", undefined>;
             }, undefined> | import("valibot").ObjectSchema<{
                 readonly args: import("valibot").ObjectSchema<{
                     readonly envelope: Omit<import("valibot").ObjectSchema<{
@@ -729,38 +728,24 @@ 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 settings: Omit<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>;
-                    }, undefined>, "~standard" | "~run" | "~types" | "entries"> & {
-                        readonly entries: {
-                            readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                        };
-                        readonly '~standard': import("valibot").StandardSchemaProps<{
-                            name?: string | null | undefined;
-                        }, {
-                            name?: string | null | undefined;
-                        }>;
-                        readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                            name?: string | null | undefined;
-                        }, import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue>;
-                        readonly '~types'?: {
-                            readonly input: {
-                                name?: string | null | undefined;
-                            };
-                            readonly output: {
-                                name?: string | null | undefined;
-                            };
-                            readonly issue: import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue;
-                        } | 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>;
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"setSettings", undefined>;
-            }, undefined>[], undefined>, undefined>;
+                readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
+            }, undefined> | import("valibot").ObjectSchema<{
+                readonly args: 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>;
+                readonly clientID: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").NumberSchema<undefined>;
+                readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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/index.d.ts

@@ -289,6 +289,14 @@ 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").ObjectSchema<Record<"ios" | "osx" | "web", 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>, 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,14 @@ 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.ObjectSchema<Record<"ios" | "osx" | "web", 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 platform: v.UnionSchema<[v.LiteralSchema<"ios", undefined>, v.LiteralSchema<"osx", undefined>, v.LiteralSchema<"web", 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>, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAwBvB,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/draft.d.ts

@@ -95,15 +95,6 @@ export declare const syncPushDraft: import("../../../../..").EndpointConfig<"/v1
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
         readonly name: v.LiteralSchema<"setContent", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.ObjectSchema<{
-            readonly emailAccountId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
-            readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
-            readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-        }, undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setEmailAccountId", undefined>;
     }, undefined> | v.ObjectSchema<{
         readonly args: v.ObjectSchema<{
             readonly envelope: Omit<v.ObjectSchema<{

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

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

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

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

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

@@ -234,15 +234,6 @@ export declare const push: {
             readonly clientID: import("valibot").StringSchema<undefined>;
             readonly id: import("valibot").NumberSchema<undefined>;
             readonly name: import("valibot").LiteralSchema<"setContent", undefined>;
-        }, undefined> | import("valibot").ObjectSchema<{
-            readonly args: import("valibot").ObjectSchema<{
-                readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-            }, undefined>;
-            readonly clientID: import("valibot").StringSchema<undefined>;
-            readonly id: import("valibot").NumberSchema<undefined>;
-            readonly name: import("valibot").LiteralSchema<"setEmailAccountId", undefined>;
         }, undefined> | import("valibot").ObjectSchema<{
             readonly args: import("valibot").ObjectSchema<{
                 readonly envelope: Omit<import("valibot").ObjectSchema<{
@@ -430,38 +421,24 @@ 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 settings: Omit<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>;
-                }, undefined>, "~standard" | "~run" | "~types" | "entries"> & {
-                    readonly entries: {
-                        readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                    };
-                    readonly '~standard': import("valibot").StandardSchemaProps<{
-                        name?: string | null | undefined;
-                    }, {
-                        name?: string | null | undefined;
-                    }>;
-                    readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                        name?: string | null | undefined;
-                    }, import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue>;
-                    readonly '~types'?: {
-                        readonly input: {
-                            name?: string | null | undefined;
-                        };
-                        readonly output: {
-                            name?: string | null | undefined;
-                        };
-                        readonly issue: import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue;
-                    } | 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>;
             }, undefined>;
             readonly clientID: import("valibot").StringSchema<undefined>;
             readonly id: import("valibot").NumberSchema<undefined>;
-            readonly name: import("valibot").LiteralSchema<"setSettings", undefined>;
-        }, undefined>[], undefined>, undefined>;
+            readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
+        }, undefined> | import("valibot").ObjectSchema<{
+            readonly args: 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>;
+            readonly clientID: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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,38 +1,24 @@
 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 settings: Omit<v.ObjectSchema<{
-                readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, "~standard" | "~run" | "~types" | "entries"> & {
-                readonly entries: {
-                    readonly name: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                };
-                readonly '~standard': v.StandardSchemaProps<{
-                    name?: string | null | undefined;
-                }, {
-                    name?: string | null | undefined;
-                }>;
-                readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
-                    name?: string | null | undefined;
-                }, v.StringIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.ObjectIssue>;
-                readonly '~types'?: {
-                    readonly input: {
-                        name?: string | null | undefined;
-                    };
-                    readonly output: {
-                        name?: string | null | undefined;
-                    };
-                    readonly issue: v.StringIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.ObjectIssue;
-                } | undefined;
-            };
+            readonly name: v.NullableSchema<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<"setSettings", undefined>;
-    }, undefined>[], undefined>, undefined>;
+        readonly name: v.LiteralSchema<"setSettingsName", undefined>;
+    }, undefined> | v.ObjectSchema<{
+        readonly args: 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 platform: v.UnionSchema<[v.LiteralSchema<"ios", undefined>, v.LiteralSchema<"osx", undefined>, v.LiteralSchema<"web", undefined>], undefined>;
+            readonly token: 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<"setSettingsPushNotifactionToken", 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAuBvB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA6BvB,CAAA"}

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

@@ -6,11 +6,17 @@ export const syncPushUser = createEndpoint({
     body: v.object({
         clientGroupID: v.string(),
         mutations: v.array(v.union(Object.values({
-            setSettings: v.object({
-                args: user.mutators.setSettings.delta,
+            setSettingsName: v.object({
+                args: user.mutators.setSettingsName.delta,
                 clientID: v.string(),
                 id: v.number(),
-                name: v.literal('setSettings'),
+                name: v.literal('setSettingsName'),
+            }),
+            setSettingsPushNotifactionToken: v.object({
+                args: user.mutators.setSettingsPushNotifactionToken.delta,
+                clientID: v.string(),
+                id: v.number(),
+                name: v.literal('setSettingsPushNotifactionToken'),
             }),
         }))),
     }),

package/dist/sdk/index.d.ts

@@ -325,6 +325,14 @@ 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").ObjectSchema<Record<"ios" | "osx" | "web", 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>, undefined>;
@@ -568,15 +576,6 @@ export declare const marcoSDK: {
                             readonly clientID: import("valibot").StringSchema<undefined>;
                             readonly id: import("valibot").NumberSchema<undefined>;
                             readonly name: import("valibot").LiteralSchema<"setContent", undefined>;
-                        }, undefined> | import("valibot").ObjectSchema<{
-                            readonly args: import("valibot").ObjectSchema<{
-                                readonly emailAccountId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                                readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
-                                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-                            }, undefined>;
-                            readonly clientID: import("valibot").StringSchema<undefined>;
-                            readonly id: import("valibot").NumberSchema<undefined>;
-                            readonly name: import("valibot").LiteralSchema<"setEmailAccountId", undefined>;
                         }, undefined> | import("valibot").ObjectSchema<{
                             readonly args: import("valibot").ObjectSchema<{
                                 readonly envelope: Omit<import("valibot").ObjectSchema<{
@@ -764,38 +763,24 @@ 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 settings: Omit<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>;
-                                }, undefined>, "~standard" | "~run" | "~types" | "entries"> & {
-                                    readonly entries: {
-                                        readonly name: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                                    };
-                                    readonly '~standard': import("valibot").StandardSchemaProps<{
-                                        name?: string | null | undefined;
-                                    }, {
-                                        name?: string | null | undefined;
-                                    }>;
-                                    readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
-                                        name?: string | null | undefined;
-                                    }, import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue>;
-                                    readonly '~types'?: {
-                                        readonly input: {
-                                            name?: string | null | undefined;
-                                        };
-                                        readonly output: {
-                                            name?: string | null | undefined;
-                                        };
-                                        readonly issue: import("valibot").StringIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").ObjectIssue;
-                                    } | 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>;
                             }, undefined>;
                             readonly clientID: import("valibot").StringSchema<undefined>;
                             readonly id: import("valibot").NumberSchema<undefined>;
-                            readonly name: import("valibot").LiteralSchema<"setSettings", undefined>;
-                        }, undefined>[], undefined>, undefined>;
+                            readonly name: import("valibot").LiteralSchema<"setSettingsName", undefined>;
+                        }, undefined> | import("valibot").ObjectSchema<{
+                            readonly args: 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 platform: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", 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>;
+                            readonly clientID: import("valibot").StringSchema<undefined>;
+                            readonly id: import("valibot").NumberSchema<undefined>;
+                            readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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/types/index.d.ts

@@ -1,6 +1,6 @@
 export * from './EmailProvider';
 export * from './Endpoint';
 export * from './MarcoClient';
-export * from './WS';
 export * from './SDKError';
+export * from './WS';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,MAAM,CAAA;AACpB,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,MAAM,CAAA"}

package/dist/types/index.js

@@ -1,5 +1,5 @@
 export * from './EmailProvider';
 export * from './Endpoint';
 export * from './MarcoClient';
-export * from './WS';
 export * from './SDKError';
+export * from './WS';

package/package.json

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