@marcoappio/marco-config 2.0.330 → 2.0.332

package/dist/clients/account.js

@@ -26,7 +26,7 @@ export const account = {
             }),
             name: marcoSchemas.string.required(),
             path: marcoSchemas.string.required(),
-            specialUse: v.nullable(marcoSchemas.labelSpecialUse()),
+            specialUse: v.nullable(marcoSchemas.labels.specialUse()),
         })),
         settings: accountSettingsSchema,
     }),

package/dist/clients/index.d.ts

@@ -459,7 +459,7 @@ 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>;
             };
-            setSettingsPushNotifactionToken: {
+            setSettingsPushNotificationToken: {
                 delta: import("valibot").ObjectSchema<{
                     readonly id: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
                     readonly pushNotificationToken: import("valibot").ObjectSchema<{

package/dist/clients/user.d.ts

@@ -21,7 +21,7 @@ export declare const user: {
                 readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             }, undefined>;
         };
-        setSettingsPushNotifactionToken: {
+        setSettingsPushNotificationToken: {
             delta: v.ObjectSchema<{
                 readonly id: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
                 readonly pushNotificationToken: v.ObjectSchema<{

package/dist/clients/user.js

@@ -25,7 +25,7 @@ export const user = {
                 name: marcoSchemas.string.nullable(),
             }),
         },
-        setSettingsPushNotifactionToken: {
+        setSettingsPushNotificationToken: {
             delta: v.object({
                 id: marcoSchemas.string.shortUUID(),
                 pushNotificationToken,

package/dist/schemas/app.d.ts

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export declare const app: {
+    platform: () => v.UnionSchema<[v.LiteralSchema<"ios", undefined>, v.LiteralSchema<"osx", undefined>, v.LiteralSchema<"web", undefined>], undefined>;
+};
+//# sourceMappingURL=app.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/schemas/app.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,GAAG;;CAMf,CAAA"}

package/dist/schemas/app.js

@@ -0,0 +1,8 @@
+import * as v from 'valibot';
+export const app = {
+    platform: () => v.union([
+        v.literal('ios'),
+        v.literal('osx'),
+        v.literal('web'),
+    ]),
+};

package/dist/schemas/drafts.d.ts

@@ -0,0 +1,16 @@
+import * as v from 'valibot';
+export declare const drafts: {
+    contentPatch: {
+        instruction: () => v.ObjectSchema<{
+            readonly index: v.NumberSchema<undefined>;
+            readonly type: v.UnionSchema<[v.LiteralSchema<"INSERTION", undefined>, v.LiteralSchema<"DELETION", undefined>], undefined>;
+            readonly value: v.StringSchema<undefined>;
+        }, undefined>;
+        patch: () => v.ArraySchema<v.ObjectSchema<{
+            readonly index: v.NumberSchema<undefined>;
+            readonly type: v.UnionSchema<[v.LiteralSchema<"INSERTION", undefined>, v.LiteralSchema<"DELETION", undefined>], undefined>;
+            readonly value: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    };
+};
+//# sourceMappingURL=drafts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drafts.d.ts","sourceRoot":"","sources":["../../src/schemas/drafts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAW5B,eAAO,MAAM,MAAM;;;;;;;;;;;;;CAKlB,CAAA"}

package/dist/schemas/drafts.js

@@ -0,0 +1,15 @@
+import * as v from 'valibot';
+const patchInstructionSchema = v.object({
+    index: v.number(),
+    type: v.union([
+        v.literal('INSERTION'),
+        v.literal('DELETION'),
+    ]),
+    value: v.string(),
+});
+export const drafts = {
+    contentPatch: {
+        instruction: () => patchInstructionSchema,
+        patch: () => v.array(patchInstructionSchema),
+    },
+};

package/dist/schemas/emailAccount.d.ts

@@ -0,0 +1,17 @@
+import * as v from 'valibot';
+export declare const emailAccount: {
+    connectionConfigImapRaw: () => v.ObjectSchema<{
+        readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
+        readonly smtpHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly smtpPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly smtpPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
+    }, undefined>;
+    connectionConfigOauth: () => v.ObjectSchema<{
+        readonly code: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly provider: v.UnionSchema<[v.LiteralSchema<"GOOGLE", undefined>, v.LiteralSchema<"OUTLOOK", undefined>], undefined>;
+    }, undefined>;
+    imapConnectionStatus: () => v.UnionSchema<[v.LiteralSchema<"AWAITING_CONNECTION", undefined>, v.LiteralSchema<"CONNECTED", undefined>, v.LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
+};
+//# sourceMappingURL=emailAccount.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emailAccount.d.ts","sourceRoot":"","sources":["../../src/schemas/emailAccount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAsBxB,CAAA"}

package/dist/schemas/emailAccount.js

@@ -0,0 +1,27 @@
+import * as v from 'valibot';
+import { number } from './number';
+import { oauth } from './oauth';
+import { string } from './string';
+export const emailAccount = {
+    connectionConfigImapRaw: () => v.object({
+        imapHost: string.required(),
+        imapPassword: string.required(),
+        imapPort: number.minMax(1, 65535),
+        smtpHost: string.required(),
+        smtpPassword: string.required(),
+        smtpPort: number.minMax(1, 65535),
+    }),
+    connectionConfigOauth: () => v.object({
+        code: string.required(),
+        provider: oauth.provider(),
+    }),
+    imapConnectionStatus: () => v.union([
+        v.literal('AWAITING_CONNECTION'),
+        v.literal('CONNECTED'),
+        v.literal('CONNECTION_FAILED_CONNECTION_ERROR'),
+        v.literal('CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR'), // TODO: Deprecate this
+        v.literal('CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR'),
+        v.literal('CONNECTION_FAILED_AUTHENTICATION_ERROR'),
+        v.literal('CONNECTION_FAILED_UNKNOWN_ERROR'),
+    ]),
+};

package/dist/schemas/index.d.ts

@@ -1,55 +1,63 @@
-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>;
+        platform: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", undefined>], undefined>;
     };
     drafts: {
         contentPatch: {
-            instruction: () => v.ObjectSchema<{
-                readonly index: v.NumberSchema<undefined>;
-                readonly type: v.UnionSchema<[v.LiteralSchema<"INSERTION", undefined>, v.LiteralSchema<"DELETION", undefined>], undefined>;
-                readonly value: v.StringSchema<undefined>;
+            instruction: () => import("valibot").ObjectSchema<{
+                readonly index: import("valibot").NumberSchema<undefined>;
+                readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"INSERTION", undefined>, import("valibot").LiteralSchema<"DELETION", undefined>], undefined>;
+                readonly value: import("valibot").StringSchema<undefined>;
             }, undefined>;
-            patch: () => v.ArraySchema<v.ObjectSchema<{
-                readonly index: v.NumberSchema<undefined>;
-                readonly type: v.UnionSchema<[v.LiteralSchema<"INSERTION", undefined>, v.LiteralSchema<"DELETION", undefined>], undefined>;
-                readonly value: v.StringSchema<undefined>;
+            patch: () => import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly index: import("valibot").NumberSchema<undefined>;
+                readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"INSERTION", undefined>, import("valibot").LiteralSchema<"DELETION", undefined>], undefined>;
+                readonly value: import("valibot").StringSchema<undefined>;
             }, undefined>, undefined>;
         };
     };
     emailAccount: {
-        connectionConfigImapRaw: () => v.ObjectSchema<{
-            readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-            readonly smtpHost: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly smtpPassword: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly smtpPort: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
+        connectionConfigImapRaw: () => import("valibot").ObjectSchema<{
+            readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly imapPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
+            readonly smtpHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly smtpPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly smtpPort: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
         }, undefined>;
-        connectionConfigOauth: () => v.ObjectSchema<{
-            readonly code: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly provider: v.UnionSchema<[v.LiteralSchema<"GOOGLE", undefined>, v.LiteralSchema<"OUTLOOK", undefined>], undefined>;
+        connectionConfigOauth: () => import("valibot").ObjectSchema<{
+            readonly code: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly provider: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"GOOGLE", undefined>, import("valibot").LiteralSchema<"OUTLOOK", undefined>], undefined>;
         }, undefined>;
-        imapConnectionStatus: () => v.UnionSchema<[v.LiteralSchema<"AWAITING_CONNECTION", undefined>, v.LiteralSchema<"CONNECTED", undefined>, v.LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
+        imapConnectionStatus: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
+    };
+    labels: {
+        specialUse: () => 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>;
     };
-    labelSpecialUse: () => v.UnionSchema<[v.LiteralSchema<"ARCHIVE", undefined>, v.LiteralSchema<"INBOX", undefined>, v.LiteralSchema<"SENT", undefined>, v.LiteralSchema<"SPAM", undefined>, v.LiteralSchema<"TRASH", undefined>], undefined>;
     number: {
-        minMax: (min: number, max: number) => v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-        positiveInteger: () => v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        minMax: (min: number, max: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
+        positiveInteger: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
     };
     oauth: {
-        provider: () => v.UnionSchema<[v.LiteralSchema<"GOOGLE", undefined>, v.LiteralSchema<"OUTLOOK", undefined>], undefined>;
+        provider: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"GOOGLE", undefined>, import("valibot").LiteralSchema<"OUTLOOK", undefined>], undefined>;
+    };
+    pushNotifications: {
+        payload: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly threadId: import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+            }, undefined>;
+            readonly event: import("valibot").LiteralSchema<"EMAIL_RECEIVED", undefined>;
+        }, undefined>], undefined>;
     };
     string: {
-        email: () => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-        enum: (values: Record<string, string>) => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EnumSchema<Record<string, string>, undefined>]>, undefined>;
-        matches: (regex: RegExp) => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
-        nullable: (maxLength?: number) => v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        optional: (maxLength?: number) => v.UndefinedableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        required: (maxLength?: number) => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        shortUUID: () => v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
-        uuid: () => v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.UuidAction<string, undefined>]>, undefined>;
+        email: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+        enum: (values: Record<string, string>) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EnumSchema<Record<string, string>, undefined>]>, undefined>;
+        matches: (regex: RegExp) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, undefined>]>, undefined>;
+        nullable: (maxLength?: number) => import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+        optional: (maxLength?: number) => import("valibot").UndefinedableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+        required: (maxLength?: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+        shortUUID: () => import("valibot").CustomSchema<string, import("valibot").ErrorMessage<import("valibot").CustomIssue> | undefined>;
+        uuid: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").UuidAction<string, undefined>]>, undefined>;
     };
 };
-export type LabelSpecialUse = v.InferInput<ReturnType<typeof marcoSchemas.labelSpecialUse>>;
 //# sourceMappingURL=index.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA6CP,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":"AAUA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASxB,CAAA"}

package/dist/schemas/index.js

@@ -1,66 +1,18 @@
-import * as v from 'valibot';
 import { string } from '../schemas/string';
-const patchInstructionSchema = v.object({
-    index: v.number(),
-    type: v.union([
-        v.literal('INSERTION'),
-        v.literal('DELETION'),
-    ]),
-    value: v.string(),
-});
+import { app } from './app';
+import { drafts } from './drafts';
+import { emailAccount } from './emailAccount';
+import { labels } from './labels';
+import { number } from './number';
+import { oauth } from './oauth';
+import { pushNotifications } from './pushNotifications';
 export const marcoSchemas = {
-    app: {
-        platform: () => v.union([
-            v.literal('ios'),
-            v.literal('osx'),
-            v.literal('web'),
-        ]),
-    },
-    drafts: {
-        contentPatch: {
-            instruction: () => patchInstructionSchema,
-            patch: () => v.array(patchInstructionSchema),
-        },
-    },
-    emailAccount: {
-        connectionConfigImapRaw: () => v.object({
-            imapHost: marcoSchemas.string.required(),
-            imapPassword: marcoSchemas.string.required(),
-            imapPort: marcoSchemas.number.minMax(1, 65535),
-            smtpHost: marcoSchemas.string.required(),
-            smtpPassword: marcoSchemas.string.required(),
-            smtpPort: marcoSchemas.number.minMax(1, 65535),
-        }),
-        connectionConfigOauth: () => v.object({
-            code: marcoSchemas.string.required(),
-            provider: marcoSchemas.oauth.provider(),
-        }),
-        imapConnectionStatus: () => v.union([
-            v.literal('AWAITING_CONNECTION'),
-            v.literal('CONNECTED'),
-            v.literal('CONNECTION_FAILED_CONNECTION_ERROR'),
-            v.literal('CONNECTION_FAILED_OAUTH_GOOGLE_EXCHANGE_ERROR'), // TODO: Deprecate this
-            v.literal('CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR'),
-            v.literal('CONNECTION_FAILED_AUTHENTICATION_ERROR'),
-            v.literal('CONNECTION_FAILED_UNKNOWN_ERROR'),
-        ]),
-    },
-    labelSpecialUse: () => v.union([
-        v.literal('ARCHIVE'),
-        v.literal('INBOX'),
-        v.literal('SENT'),
-        v.literal('SPAM'),
-        v.literal('TRASH'),
-    ]),
-    number: {
-        minMax: (min, max) => v.nonOptional(v.pipe(v.number(), v.minValue(min), v.maxValue(max))),
-        positiveInteger: () => v.nonOptional(v.pipe(v.number(), v.integer(), v.minValue(0))),
-    },
-    oauth: {
-        provider: () => v.union([
-            v.literal('GOOGLE'),
-            v.literal('OUTLOOK'),
-        ]),
-    },
-    string: string,
+    app,
+    drafts,
+    emailAccount,
+    labels,
+    number,
+    oauth,
+    pushNotifications,
+    string,
 };

package/dist/schemas/labels.d.ts

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export declare const labels: {
+    specialUse: () => v.UnionSchema<[v.LiteralSchema<"ARCHIVE", undefined>, v.LiteralSchema<"INBOX", undefined>, v.LiteralSchema<"SENT", undefined>, v.LiteralSchema<"SPAM", undefined>, v.LiteralSchema<"TRASH", undefined>], undefined>;
+};
+//# sourceMappingURL=labels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/schemas/labels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,MAAM;;CAQlB,CAAA"}

package/dist/schemas/labels.js

@@ -0,0 +1,10 @@
+import * as v from 'valibot';
+export const labels = {
+    specialUse: () => v.union([
+        v.literal('ARCHIVE'),
+        v.literal('INBOX'),
+        v.literal('SENT'),
+        v.literal('SPAM'),
+        v.literal('TRASH'),
+    ]),
+};

package/dist/schemas/number.d.ts

@@ -0,0 +1,6 @@
+import * as v from 'valibot';
+export declare const number: {
+    minMax: (min: number, max: number) => v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
+    positiveInteger: () => v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+};
+//# sourceMappingURL=number.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/schemas/number.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,MAAM;kBACH,MAAM,OAAO,MAAM;;CAIlC,CAAA"}

package/dist/schemas/number.js

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export const number = {
+    minMax: (min, max) => v.nonOptional(v.pipe(v.number(), v.minValue(min), v.maxValue(max))),
+    positiveInteger: () => v.nonOptional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+};

package/dist/schemas/oauth.d.ts

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export declare const oauth: {
+    provider: () => v.UnionSchema<[v.LiteralSchema<"GOOGLE", undefined>, v.LiteralSchema<"OUTLOOK", undefined>], undefined>;
+};
+//# sourceMappingURL=oauth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../src/schemas/oauth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,KAAK;;CAKjB,CAAA"}

package/dist/schemas/oauth.js

@@ -0,0 +1,7 @@
+import * as v from 'valibot';
+export const oauth = {
+    provider: () => v.union([
+        v.literal('GOOGLE'),
+        v.literal('OUTLOOK'),
+    ]),
+};

package/dist/schemas/pushNotifications.d.ts

@@ -0,0 +1,10 @@
+import * as v from 'valibot';
+export declare const pushNotifications: {
+    payload: v.UnionSchema<[v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly threadId: v.CustomSchema<string, v.ErrorMessage<v.CustomIssue> | undefined>;
+        }, undefined>;
+        readonly event: v.LiteralSchema<"EMAIL_RECEIVED", undefined>;
+    }, undefined>], undefined>;
+};
+//# sourceMappingURL=pushNotifications.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pushNotifications.d.ts","sourceRoot":"","sources":["../../src/schemas/pushNotifications.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAe5B,eAAO,MAAM,iBAAiB;;;;;;;CAE7B,CAAA"}

package/dist/schemas/pushNotifications.js

@@ -0,0 +1,14 @@
+import * as v from 'valibot';
+import { string } from './string';
+const pushNotificationEmailReceivedPayload = v.object({
+    data: v.object({
+        threadId: string.shortUUID(),
+    }),
+    event: v.literal('EMAIL_RECEIVED'),
+});
+const pushNotificationPayload = v.union([
+    pushNotificationEmailReceivedPayload,
+]);
+export const pushNotifications = {
+    payload: pushNotificationPayload,
+};

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

@@ -784,7 +784,7 @@ export declare const endpoints: {
                         }, undefined>;
                         readonly clientID: import("valibot").StringSchema<undefined>;
                         readonly id: import("valibot").NumberSchema<undefined>;
-                        readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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<{

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

@@ -781,7 +781,7 @@ export declare const privateGroup: {
                     }, undefined>;
                     readonly clientID: import("valibot").StringSchema<undefined>;
                     readonly id: import("valibot").NumberSchema<undefined>;
-                    readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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<{

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

@@ -748,7 +748,7 @@ export declare const sync: {
                 }, undefined>;
                 readonly clientID: import("valibot").StringSchema<undefined>;
                 readonly id: import("valibot").NumberSchema<undefined>;
-                readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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<{

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

@@ -441,7 +441,7 @@ export declare const push: {
             }, undefined>;
             readonly clientID: import("valibot").StringSchema<undefined>;
             readonly id: import("valibot").NumberSchema<undefined>;
-            readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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<{

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

@@ -21,7 +21,7 @@ export declare const syncPushUser: import("../../../../..").EndpointConfig<"/v1/
         }, undefined>;
         readonly clientID: v.StringSchema<undefined>;
         readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setSettingsPushNotifactionToken", 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<{

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

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

package/dist/sdk/index.d.ts

@@ -783,7 +783,7 @@ export declare const marcoSDK: {
                             }, undefined>;
                             readonly clientID: import("valibot").StringSchema<undefined>;
                             readonly id: import("valibot").NumberSchema<undefined>;
-                            readonly name: import("valibot").LiteralSchema<"setSettingsPushNotifactionToken", 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<{

package/dist/types/MarcoClient.d.ts

@@ -10,5 +10,5 @@ export type MarcoClient = {
     pushUrl: string | null;
     schemaVersion: string;
 };
-export type LabelSpecialUse = v.InferOutput<ReturnType<typeof marcoSchemas.labelSpecialUse>>;
+export type LabelSpecialUse = v.InferOutput<ReturnType<typeof marcoSchemas.labels.specialUse>>;
 //# sourceMappingURL=MarcoClient.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MarcoClient.d.ts","sourceRoot":"","sources":["../../src/types/MarcoClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IAC/B,QAAQ,EAAE,MAAM,CACd,MAAM,EACN;QACE,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;KAChC,CACF,CAAA;IACD,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA"}
+{"version":3,"file":"MarcoClient.d.ts","sourceRoot":"","sources":["../../src/types/MarcoClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IAC/B,QAAQ,EAAE,MAAM,CACd,MAAM,EACN;QACE,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;KAChC,CACF,CAAA;IACD,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAA"}

package/package.json

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