@marcoappio/marco-config 2.0.409 → 2.0.410

package/dist/instantDB/instant.perms.d.ts

@@ -0,0 +1,140 @@
+declare const rules: {
+    $users: {
+        allow: {
+            view: string;
+        };
+        bind: string[];
+    };
+    accountMailCounts: {
+        allow: {
+            view: string;
+        };
+        bind: string[];
+    };
+    accountSettings: {
+        allow: {
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+    accounts: {
+        allow: {
+            create: string;
+            delete: string;
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+    aliases: {
+        allow: {
+            create: string;
+            delete: string;
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+    contacts: {
+        allow: {
+            view: string;
+        };
+        bind: string[];
+    };
+    draftAttachments: {
+        allow: {
+            create: string;
+            delete: string;
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+    draftRecipients: {
+        allow: {
+            create: string;
+            delete: string;
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+    drafts: {
+        allow: {
+            create: string;
+            delete: string;
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+    labels: {
+        allow: {
+            view: string;
+        };
+        bind: string[];
+    };
+    messageAttachments: {
+        allow: {
+            view: string;
+        };
+        bind: string[];
+    };
+    messageLabels: {
+        allow: {
+            create: string;
+            delete: string;
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+    messageRecipients: {
+        allow: {
+            view: string;
+        };
+        bind: string[];
+    };
+    messages: {
+        allow: {
+            view: string;
+        };
+        bind: string[];
+    };
+    threadBagOfWords: {
+        allow: {
+            view: string;
+        };
+        bind: string[];
+    };
+    threads: {
+        allow: {
+            create: string;
+            delete: string;
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+    userPushNotificationToken: {
+        allow: {
+            create: string;
+            delete: string;
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+    userSettings: {
+        allow: {
+            create: string;
+            delete: string;
+            update: string;
+            view: string;
+        };
+        bind: string[];
+    };
+};
+export default rules;
+//# sourceMappingURL=instant.perms.d.ts.map

package/dist/instantDB/instant.perms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instant.perms.d.ts","sourceRoot":"","sources":["../../src/instantDB/instant.perms.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyIa,CAAA;AAExB,eAAe,KAAK,CAAA"}

package/dist/instantDB/instant.perms.js

@@ -0,0 +1,139 @@
+const rules = {
+    $users: {
+        allow: {
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.id == auth.id'],
+    },
+    accountMailCounts: {
+        allow: {
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.account.user.id == auth.id'],
+    },
+    accountSettings: {
+        allow: {
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.account.user.id == auth.id'],
+    },
+    accounts: {
+        allow: {
+            create: 'isOwner',
+            delete: 'isOwner',
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.user.id == auth.id'],
+    },
+    aliases: {
+        allow: {
+            create: 'isOwner',
+            delete: 'isOwner',
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.account.user.id == auth.id'],
+    },
+    contacts: {
+        allow: {
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.user.id == auth.id'],
+    },
+    draftAttachments: {
+        allow: {
+            create: 'isOwner',
+            delete: 'isOwner',
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.draft.account.user.id == auth.id'],
+    },
+    draftRecipients: {
+        allow: {
+            create: 'isOwner',
+            delete: 'isOwner',
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.draft.account.user.id == auth.id'],
+    },
+    drafts: {
+        allow: {
+            create: 'isOwner',
+            delete: 'isOwner',
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.account.user.id == auth.id'],
+    },
+    labels: {
+        allow: {
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.account.user.id == auth.id'],
+    },
+    messageAttachments: {
+        allow: {
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.message.thread.account.user.id == auth.id'],
+    },
+    messageLabels: {
+        allow: {
+            create: 'isOwner',
+            delete: 'isOwner',
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.message.thread.account.user.id == auth.id'],
+    },
+    messageRecipients: {
+        allow: {
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.message.thread.account.user.id == auth.id'],
+    },
+    messages: {
+        allow: {
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.thread.account.user.id == auth.id'],
+    },
+    threadBagOfWords: {
+        allow: {
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.thread.account.user.id == auth.id'],
+    },
+    threads: {
+        allow: {
+            create: 'isOwner',
+            delete: 'isOwner',
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.account.user.id == auth.id'],
+    },
+    userPushNotificationToken: {
+        allow: {
+            create: 'isOwner',
+            delete: 'isOwner',
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.userSettings.user.id == auth.id'],
+    },
+    userSettings: {
+        allow: {
+            create: 'isOwner',
+            delete: 'isOwner',
+            update: 'isOwner',
+            view: 'isOwner',
+        },
+        bind: ['isOwner', 'data.user.id == auth.id'],
+    },
+};
+export default rules;

package/dist/instantDB/instant.schema.d.ts

@@ -0,0 +1,336 @@
+import type { DraftRecipientType, DraftStatus, DraftType, ImapConnectionStatus, LabelSpecialUse, MessageAttachmentStatus, MessageRecipientType } from '../types';
+declare const schema: import("@instantdb/core").InstantSchemaDef<import("@instantdb/core").EntitiesWithLinks<{
+    $users: import("@instantdb/core").EntityDef<{
+        email: import("@instantdb/core").DataAttrDef<string, true, true>;
+    }, {}, void>;
+    accountMailCounts: import("@instantdb/core").EntityDef<{
+        processed: import("@instantdb/core").DataAttrDef<number, true, true>;
+        total: import("@instantdb/core").DataAttrDef<number, true, true>;
+    }, {}, void>;
+    accountSettings: import("@instantdb/core").EntityDef<{
+        color: import("@instantdb/core").DataAttrDef<string, true, false>;
+        name: import("@instantdb/core").DataAttrDef<string, false, false>;
+    }, {}, void>;
+    accounts: import("@instantdb/core").EntityDef<{
+        imapConnectionStatus: import("@instantdb/core").DataAttrDef<string, true, true>;
+    }, {}, void>;
+    aliases: import("@instantdb/core").EntityDef<{
+        emailAddress: import("@instantdb/core").DataAttrDef<string, true, true>;
+        isPrimary: import("@instantdb/core").DataAttrDef<boolean, true, true>;
+        name: import("@instantdb/core").DataAttrDef<string, false, false>;
+    }, {}, void>;
+    contacts: import("@instantdb/core").EntityDef<{
+        emailAddress: import("@instantdb/core").DataAttrDef<string, true, true>;
+        name: import("@instantdb/core").DataAttrDef<string, false, false>;
+    }, {}, void>;
+    draftAttachments: import("@instantdb/core").EntityDef<{
+        failed: import("@instantdb/core").DataAttrDef<boolean, true, false>;
+        fileName: import("@instantdb/core").DataAttrDef<string, true, false>;
+        mimeType: import("@instantdb/core").DataAttrDef<string, true, false>;
+        totalChunks: import("@instantdb/core").DataAttrDef<number, true, false>;
+        totalSize: import("@instantdb/core").DataAttrDef<number, true, false>;
+        uploadedChunks: import("@instantdb/core").DataAttrDef<number, true, false>;
+    }, {}, void>;
+    draftRecipients: import("@instantdb/core").EntityDef<{
+        emailAddress: import("@instantdb/core").DataAttrDef<string, true, true>;
+        recipientType: import("@instantdb/core").DataAttrDef<string, true, true>;
+    }, {}, void>;
+    drafts: import("@instantdb/core").EntityDef<{
+        bodyContent: import("@instantdb/core").DataAttrDef<string, true, false>;
+        bodySubject: import("@instantdb/core").DataAttrDef<string, false, false>;
+        emailAccountId: import("@instantdb/core").DataAttrDef<string, true, true>;
+        error: import("@instantdb/core").DataAttrDef<string, false, false>;
+        from: import("@instantdb/core").DataAttrDef<string, true, true>;
+        fromName: import("@instantdb/core").DataAttrDef<string, false, false>;
+        referencedMessageId: import("@instantdb/core").DataAttrDef<string, false, true>;
+        scheduledFor: import("@instantdb/core").DataAttrDef<number, false, true>;
+        status: import("@instantdb/core").DataAttrDef<string, true, true>;
+        type: import("@instantdb/core").DataAttrDef<string, true, true>;
+        updatedAt: import("@instantdb/core").DataAttrDef<number, true, true>;
+    }, {}, void>;
+    labels: import("@instantdb/core").EntityDef<{
+        labelId: import("@instantdb/core").DataAttrDef<string, true, true>;
+        path: import("@instantdb/core").DataAttrDef<string, true, true>;
+        specialUse: import("@instantdb/core").DataAttrDef<string, false, true>;
+    }, {}, void>;
+    messageAttachments: import("@instantdb/core").EntityDef<{
+        attachmentId: import("@instantdb/core").DataAttrDef<string, true, true>;
+        fileName: import("@instantdb/core").DataAttrDef<string, true, false>;
+        mimeType: import("@instantdb/core").DataAttrDef<string, true, false>;
+        size: import("@instantdb/core").DataAttrDef<number, true, false>;
+        status: import("@instantdb/core").DataAttrDef<string, true, true>;
+    }, {}, void>;
+    messageLabels: import("@instantdb/core").EntityDef<{
+        labelId: import("@instantdb/core").DataAttrDef<string, true, true>;
+    }, {}, void>;
+    messageRecipients: import("@instantdb/core").EntityDef<{
+        emailAddress: import("@instantdb/core").DataAttrDef<string, true, true>;
+        name: import("@instantdb/core").DataAttrDef<string, false, false>;
+        recipientType: import("@instantdb/core").DataAttrDef<string, true, true>;
+    }, {}, void>;
+    messages: import("@instantdb/core").EntityDef<{
+        envelopeDate: import("@instantdb/core").DataAttrDef<number, true, true>;
+        envelopeSubject: import("@instantdb/core").DataAttrDef<string, false, false>;
+        fromEmailAddress: import("@instantdb/core").DataAttrDef<string, true, true>;
+        fromName: import("@instantdb/core").DataAttrDef<string, false, false>;
+        messageId: import("@instantdb/core").DataAttrDef<string, true, true>;
+        previewText: import("@instantdb/core").DataAttrDef<string, true, false>;
+    }, {}, void>;
+    threadBagOfWords: import("@instantdb/core").EntityDef<{
+        word: import("@instantdb/core").DataAttrDef<string, true, true>;
+    }, {}, void>;
+    threads: import("@instantdb/core").EntityDef<{
+        emailAccountId: import("@instantdb/core").DataAttrDef<string, true, true>;
+        flagged: import("@instantdb/core").DataAttrDef<boolean, true, true>;
+        labelIds: import("@instantdb/core").DataAttrDef<any, true, false>;
+        latestMessageDate: import("@instantdb/core").DataAttrDef<number, true, true>;
+        messageIds: import("@instantdb/core").DataAttrDef<any, true, false>;
+        participants: import("@instantdb/core").DataAttrDef<any, true, false>;
+        seen: import("@instantdb/core").DataAttrDef<boolean, true, true>;
+    }, {}, void>;
+    userPushNotificationToken: import("@instantdb/core").EntityDef<{
+        createdAt: import("@instantdb/core").DataAttrDef<number, true, true>;
+        token: import("@instantdb/core").DataAttrDef<string, true, true>;
+    }, {}, void>;
+    userSettings: import("@instantdb/core").EntityDef<{
+        name: import("@instantdb/core").DataAttrDef<string, false, false>;
+        profilePicture: import("@instantdb/core").DataAttrDef<string, false, false>;
+        undoSendEnabled: import("@instantdb/core").DataAttrDef<boolean, true, false>;
+    }, {}, void>;
+}, {
+    readonly accountAliases: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "account";
+            readonly on: "aliases";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "aliases";
+            readonly on: "accounts";
+        };
+    };
+    readonly accountLabels: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "account";
+            readonly on: "labels";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "labels";
+            readonly on: "accounts";
+        };
+    };
+    readonly accountMailCountsLink: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "account";
+            readonly on: "accountMailCounts";
+        };
+        readonly reverse: {
+            readonly has: "one";
+            readonly label: "mailCounts";
+            readonly on: "accounts";
+        };
+    };
+    readonly accountSettingsLink: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "account";
+            readonly on: "accountSettings";
+        };
+        readonly reverse: {
+            readonly has: "one";
+            readonly label: "settings";
+            readonly on: "accounts";
+        };
+    };
+    readonly draftAccount: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "account";
+            readonly on: "drafts";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "drafts";
+            readonly on: "accounts";
+        };
+    };
+    readonly draftAttachmentLinks: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "draft";
+            readonly on: "draftAttachments";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "attachments";
+            readonly on: "drafts";
+        };
+    };
+    readonly draftRecipientLinks: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "draft";
+            readonly on: "draftRecipients";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "bodyRecipients";
+            readonly on: "drafts";
+        };
+    };
+    readonly messageAttachmentLinks: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "message";
+            readonly on: "messageAttachments";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "attachments";
+            readonly on: "messages";
+        };
+    };
+    readonly messageLabelLinks: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "message";
+            readonly on: "messageLabels";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "labelIds";
+            readonly on: "messages";
+        };
+    };
+    readonly messageRecipientLinks: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "message";
+            readonly on: "messageRecipients";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "recipients";
+            readonly on: "messages";
+        };
+    };
+    readonly threadAccount: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "account";
+            readonly on: "threads";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "threads";
+            readonly on: "accounts";
+        };
+    };
+    readonly threadBagOfWordsLinks: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "thread";
+            readonly on: "threadBagOfWords";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "bagOfWords";
+            readonly on: "threads";
+        };
+    };
+    readonly threadMessages: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "thread";
+            readonly on: "messages";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "messages";
+            readonly on: "threads";
+        };
+    };
+    readonly userAccounts: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "user";
+            readonly on: "accounts";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "accounts";
+            readonly on: "$users";
+        };
+    };
+    readonly userContacts: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "user";
+            readonly on: "contacts";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "contacts";
+            readonly on: "$users";
+        };
+    };
+    readonly userSettingsLink: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "user";
+            readonly on: "userSettings";
+        };
+        readonly reverse: {
+            readonly has: "one";
+            readonly label: "settings";
+            readonly on: "$users";
+        };
+    };
+    readonly userSettingsPushTokens: {
+        readonly forward: {
+            readonly has: "one";
+            readonly label: "userSettings";
+            readonly on: "userPushNotificationToken";
+        };
+        readonly reverse: {
+            readonly has: "many";
+            readonly label: "pushNotificationTokens";
+            readonly on: "userSettings";
+        };
+    };
+}>, import("@instantdb/core").LinksDef<any>, {}>;
+type BaseAppSchema = typeof schema;
+export type AppSchema = {
+    [K in keyof BaseAppSchema]: K extends 'entities' ? {
+        accounts: Omit<BaseAppSchema['entities']['accounts'], 'imapConnectionStatus'> & {
+            imapConnectionStatus: ImapConnectionStatus;
+        };
+        draftRecipients: Omit<BaseAppSchema['entities']['draftRecipients'], 'recipientType'> & {
+            recipientType: DraftRecipientType;
+        };
+        drafts: Omit<BaseAppSchema['entities']['drafts'], 'status' | 'type'> & {
+            status: DraftStatus;
+            type: DraftType;
+        };
+        labels: Omit<BaseAppSchema['entities']['labels'], 'specialUse'> & {
+            specialUse: LabelSpecialUse | null;
+        };
+        messageAttachments: Omit<BaseAppSchema['entities']['messageAttachments'], 'status'> & {
+            status: MessageAttachmentStatus;
+        };
+        messageRecipients: Omit<BaseAppSchema['entities']['messageRecipients'], 'recipientType'> & {
+            recipientType: MessageRecipientType;
+        };
+        threads: Omit<BaseAppSchema['entities']['threads'], 'labelIds' | 'messageIds' | 'participants'> & {
+            labelIds: string[];
+            messageIds: string[];
+            participants: string[];
+        };
+    } & Omit<BaseAppSchema['entities'], 'accounts' | 'draftRecipients' | 'drafts' | 'labels' | 'messageAttachments' | 'messageRecipients' | 'threads'> : BaseAppSchema[K];
+};
+export default schema;
+//# sourceMappingURL=instant.schema.d.ts.map

package/dist/instantDB/instant.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instant.schema.d.ts","sourceRoot":"","sources":["../../src/instantDB/instant.schema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EACX,SAAS,EACT,oBAAoB,EACpB,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,qBAAqB,CAAA;AAE5B,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDA2KV,CAAA;AAEF,KAAK,aAAa,GAAG,OAAO,MAAM,CAAA;AAElC,MAAM,MAAM,SAAS,GAAG;KACrB,CAAC,IAAI,MAAM,aAAa,GAAG,CAAC,SAAS,UAAU,GAC5C;QACE,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,UAAU,CAAC,EAAE,sBAAsB,CAAC,GAAG;YAC9E,oBAAoB,EAAE,oBAAoB,CAAA;SAC3C,CAAA;QACD,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,iBAAiB,CAAC,EAAE,eAAe,CAAC,GAAG;YACrF,aAAa,EAAE,kBAAkB,CAAA;SAClC,CAAA;QACD,MAAM,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC,GAAG;YACrE,MAAM,EAAE,WAAW,CAAA;YACnB,IAAI,EAAE,SAAS,CAAA;SAChB,CAAA;QACD,MAAM,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC,GAAG;YAChE,UAAU,EAAE,eAAe,GAAG,IAAI,CAAA;SACnC,CAAA;QACD,kBAAkB,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,GAAG;YACpF,MAAM,EAAE,uBAAuB,CAAA;SAChC,CAAA;QACD,iBAAiB,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,mBAAmB,CAAC,EAAE,eAAe,CAAC,GAAG;YACzF,aAAa,EAAE,oBAAoB,CAAA;SACpC,CAAA;QACD,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,YAAY,GAAG,cAAc,CAAC,GAAG;YAChG,QAAQ,EAAE,MAAM,EAAE,CAAA;YAClB,UAAU,EAAE,MAAM,EAAE,CAAA;YACpB,YAAY,EAAE,MAAM,EAAE,CAAA;SACvB,CAAA;KACF,GAAG,IAAI,CACN,aAAa,CAAC,UAAU,CAAC,EACzB,UAAU,GAAG,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,GAAG,oBAAoB,GAAG,mBAAmB,GAAG,SAAS,CAC9G,GACD,aAAa,CAAC,CAAC,CAAC;CACrB,CAAA;AAED,eAAe,MAAM,CAAA"}

package/dist/instantDB/instant.schema.js

@@ -0,0 +1,174 @@
+import { i } from '@instantdb/admin';
+const schema = i.schema({
+    entities: {
+        $users: i.entity({
+            email: i.string().unique().indexed(),
+        }),
+        accountMailCounts: i.entity({
+            processed: i.number().indexed(),
+            total: i.number().indexed(),
+        }),
+        accountSettings: i.entity({
+            color: i.string(),
+            name: i.string().optional(),
+        }),
+        accounts: i.entity({
+            imapConnectionStatus: i.string().indexed(),
+        }),
+        aliases: i.entity({
+            emailAddress: i.string().indexed(),
+            isPrimary: i.boolean().indexed(),
+            name: i.string().optional(),
+        }),
+        contacts: i.entity({
+            emailAddress: i.string().indexed(),
+            name: i.string().optional(),
+        }),
+        draftAttachments: i.entity({
+            failed: i.boolean(),
+            fileName: i.string(),
+            mimeType: i.string(),
+            totalChunks: i.number(),
+            totalSize: i.number(),
+            uploadedChunks: i.number(),
+        }),
+        draftRecipients: i.entity({
+            emailAddress: i.string().indexed(),
+            recipientType: i.string().indexed(),
+        }),
+        drafts: i.entity({
+            bodyContent: i.string(),
+            bodySubject: i.string().optional(),
+            emailAccountId: i.string().indexed(),
+            error: i.string().optional(),
+            from: i.string().indexed(),
+            fromName: i.string().optional(),
+            referencedMessageId: i.string().indexed().optional(),
+            scheduledFor: i.number().indexed().optional(),
+            status: i.string().indexed(),
+            type: i.string().indexed(),
+            updatedAt: i.number().indexed(),
+        }),
+        labels: i.entity({
+            labelId: i.string().indexed(),
+            path: i.string().indexed(),
+            specialUse: i.string().indexed().optional(),
+        }),
+        messageAttachments: i.entity({
+            attachmentId: i.string().indexed(),
+            fileName: i.string(),
+            mimeType: i.string(),
+            size: i.number(),
+            status: i.string().indexed(),
+        }),
+        messageLabels: i.entity({
+            labelId: i.string().indexed(),
+        }),
+        messageRecipients: i.entity({
+            emailAddress: i.string().indexed(),
+            name: i.string().optional(),
+            recipientType: i.string().indexed(),
+        }),
+        messages: i.entity({
+            envelopeDate: i.number().indexed(),
+            envelopeSubject: i.string().optional(),
+            fromEmailAddress: i.string().indexed(),
+            fromName: i.string().optional(),
+            messageId: i.string().indexed(),
+            previewText: i.string(),
+        }),
+        threadBagOfWords: i.entity({
+            word: i.string().indexed(),
+        }),
+        threads: i.entity({
+            emailAccountId: i.string().indexed(),
+            flagged: i.boolean().indexed(),
+            labelIds: i.json(),
+            latestMessageDate: i.number().indexed(),
+            messageIds: i.json(),
+            participants: i.json(),
+            seen: i.boolean().indexed(),
+        }),
+        userPushNotificationToken: i.entity({
+            createdAt: i.number().indexed(),
+            token: i.string().unique().indexed(),
+        }),
+        userSettings: i.entity({
+            name: i.string().optional(),
+            profilePicture: i.string().optional(),
+            undoSendEnabled: i.boolean(),
+        }),
+    },
+    links: {
+        accountAliases: {
+            forward: { has: 'one', label: 'account', on: 'aliases' },
+            reverse: { has: 'many', label: 'aliases', on: 'accounts' },
+        },
+        accountLabels: {
+            forward: { has: 'one', label: 'account', on: 'labels' },
+            reverse: { has: 'many', label: 'labels', on: 'accounts' },
+        },
+        accountMailCountsLink: {
+            forward: { has: 'one', label: 'account', on: 'accountMailCounts' },
+            reverse: { has: 'one', label: 'mailCounts', on: 'accounts' },
+        },
+        accountSettingsLink: {
+            forward: { has: 'one', label: 'account', on: 'accountSettings' },
+            reverse: { has: 'one', label: 'settings', on: 'accounts' },
+        },
+        draftAccount: {
+            forward: { has: 'one', label: 'account', on: 'drafts' },
+            reverse: { has: 'many', label: 'drafts', on: 'accounts' },
+        },
+        draftAttachmentLinks: {
+            forward: { has: 'one', label: 'draft', on: 'draftAttachments' },
+            reverse: { has: 'many', label: 'attachments', on: 'drafts' },
+        },
+        draftRecipientLinks: {
+            forward: { has: 'one', label: 'draft', on: 'draftRecipients' },
+            reverse: { has: 'many', label: 'bodyRecipients', on: 'drafts' },
+        },
+        messageAttachmentLinks: {
+            forward: { has: 'one', label: 'message', on: 'messageAttachments' },
+            reverse: { has: 'many', label: 'attachments', on: 'messages' },
+        },
+        messageLabelLinks: {
+            forward: { has: 'one', label: 'message', on: 'messageLabels' },
+            reverse: { has: 'many', label: 'labelIds', on: 'messages' },
+        },
+        messageRecipientLinks: {
+            forward: { has: 'one', label: 'message', on: 'messageRecipients' },
+            reverse: { has: 'many', label: 'recipients', on: 'messages' },
+        },
+        threadAccount: {
+            forward: { has: 'one', label: 'account', on: 'threads' },
+            reverse: { has: 'many', label: 'threads', on: 'accounts' },
+        },
+        threadBagOfWordsLinks: {
+            forward: { has: 'one', label: 'thread', on: 'threadBagOfWords' },
+            reverse: { has: 'many', label: 'bagOfWords', on: 'threads' },
+        },
+        threadMessages: {
+            forward: { has: 'one', label: 'thread', on: 'messages' },
+            reverse: { has: 'many', label: 'messages', on: 'threads' },
+        },
+        userAccounts: {
+            forward: { has: 'one', label: 'user', on: 'accounts' },
+            reverse: { has: 'many', label: 'accounts', on: '$users' },
+        },
+        userContacts: {
+            forward: { has: 'one', label: 'user', on: 'contacts' },
+            reverse: { has: 'many', label: 'contacts', on: '$users' },
+        },
+        userSettingsLink: {
+            forward: { has: 'one', label: 'user', on: 'userSettings' },
+            reverse: { has: 'one', label: 'settings', on: '$users' },
+        },
+        userSettingsPushTokens: {
+            forward: { has: 'one', label: 'userSettings', on: 'userPushNotificationToken' },
+            reverse: { has: 'many', label: 'pushNotificationTokens', on: 'userSettings' },
+        },
+    },
+    rooms: {},
+});
+export default schema;

package/dist/schemas/emailAccount.d.ts

@@ -17,6 +17,6 @@ export declare const emailAccount: {
         readonly provider: v.UnionSchema<[v.LiteralSchema<"GOOGLE", undefined>, v.LiteralSchema<"OUTLOOK", undefined>], undefined>;
         readonly user: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
     }, undefined>;
-    imapConnectionStatus: () => v.UnionSchema<[v.LiteralSchema<"AWAITING_CONNECTION", undefined>, v.LiteralSchema<"CONNECTED", undefined>, v.LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_QUOTA_ERROR", undefined>, v.LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
+    imapConnectionStatus: () => v.PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "CONNECTION_FAILED_AUTHENTICATION_ERROR", "CONNECTION_FAILED_CONNECTION_ERROR", "CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", "CONNECTION_FAILED_QUOTA_ERROR", "CONNECTION_FAILED_UNKNOWN_ERROR"], undefined>;
 };
 //# sourceMappingURL=emailAccount.d.ts.map

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

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

package/dist/schemas/emailAccount.js

@@ -1,4 +1,5 @@
 import * as v from 'valibot';
+import { IMAP_CONNECTION_STATUSES } from '../types';
 import { number } from './number';
 import { oauth } from './oauth';
 import { string } from './string';
@@ -21,13 +22,5 @@ export const emailAccount = {
         provider: oauth.provider(),
         user: string.required(),
     }),
-    imapConnectionStatus: () => v.union([
-        v.literal('AWAITING_CONNECTION'),
-        v.literal('CONNECTED'),
-        v.literal('CONNECTION_FAILED_AUTHENTICATION_ERROR'),
-        v.literal('CONNECTION_FAILED_CONNECTION_ERROR'),
-        v.literal('CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR'),
-        v.literal('CONNECTION_FAILED_QUOTA_ERROR'),
-        v.literal('CONNECTION_FAILED_UNKNOWN_ERROR'),
-    ]),
+    imapConnectionStatus: () => v.picklist(IMAP_CONNECTION_STATUSES),
 };

package/dist/schemas/index.d.ts

@@ -46,10 +46,10 @@ export declare const marcoSchemas: {
             readonly provider: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"GOOGLE", undefined>, import("valibot").LiteralSchema<"OUTLOOK", undefined>], undefined>;
             readonly user: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
-        imapConnectionStatus: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"AWAITING_CONNECTION", undefined>, import("valibot").LiteralSchema<"CONNECTED", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_AUTHENTICATION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_CONNECTION_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_QUOTA_ERROR", undefined>, import("valibot").LiteralSchema<"CONNECTION_FAILED_UNKNOWN_ERROR", undefined>], undefined>;
+        imapConnectionStatus: () => import("valibot").PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "CONNECTION_FAILED_AUTHENTICATION_ERROR", "CONNECTION_FAILED_CONNECTION_ERROR", "CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", "CONNECTION_FAILED_QUOTA_ERROR", "CONNECTION_FAILED_UNKNOWN_ERROR"], 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>;
+        specialUse: () => import("valibot").PicklistSchema<readonly ["ARCHIVE", "INBOX", "SENT", "SPAM", "TRASH"], undefined>;
     };
     number: {
         minMax: (min: number, max: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;

package/dist/schemas/labels.d.ts

@@ -1,5 +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>;
+    specialUse: () => v.PicklistSchema<readonly ["ARCHIVE", "INBOX", "SENT", "SPAM", "TRASH"], undefined>;
 };
 //# sourceMappingURL=labels.d.ts.map

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

@@ -1 +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;;CAGlB,CAAA"}
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/schemas/labels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,eAAO,MAAM,MAAM;;CAElB,CAAA"}

package/dist/schemas/labels.js

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

package/dist/types/DraftRecipientType.d.ts

@@ -0,0 +1,3 @@
+export declare const DRAFT_RECIPIENT_TYPES: readonly ["bcc", "cc", "to"];
+export type DraftRecipientType = (typeof DRAFT_RECIPIENT_TYPES)[number];
+//# sourceMappingURL=DraftRecipientType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DraftRecipientType.d.ts","sourceRoot":"","sources":["../../src/types/DraftRecipientType.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,8BAA+B,CAAA;AAEjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/DraftRecipientType.js

@@ -0,0 +1 @@
+export const DRAFT_RECIPIENT_TYPES = ['bcc', 'cc', 'to'];

package/dist/types/DraftStatus.d.ts

@@ -0,0 +1,3 @@
+export declare const DRAFT_STATUSES: readonly ["DRAFT", "SEND_REQUESTED", "SEND_CONFIRMED", "SEND_FAILED"];
+export type DraftStatus = (typeof DRAFT_STATUSES)[number];
+//# sourceMappingURL=DraftStatus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DraftStatus.d.ts","sourceRoot":"","sources":["../../src/types/DraftStatus.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,uEAAwE,CAAA;AAEnG,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/DraftStatus.js

@@ -0,0 +1 @@
+export const DRAFT_STATUSES = ['DRAFT', 'SEND_REQUESTED', 'SEND_CONFIRMED', 'SEND_FAILED'];

package/dist/types/DraftType.d.ts

@@ -0,0 +1,3 @@
+export declare const DRAFT_TYPES: readonly ["NEW", "REPLY", "FORWARD"];
+export type DraftType = (typeof DRAFT_TYPES)[number];
+//# sourceMappingURL=DraftType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DraftType.d.ts","sourceRoot":"","sources":["../../src/types/DraftType.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,sCAAuC,CAAA;AAE/D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/DraftType.js

@@ -0,0 +1 @@
+export const DRAFT_TYPES = ['NEW', 'REPLY', 'FORWARD'];

package/dist/types/ImapConnectionStatus.d.ts

@@ -0,0 +1,3 @@
+export declare const IMAP_CONNECTION_STATUSES: readonly ["AWAITING_CONNECTION", "CONNECTED", "CONNECTION_FAILED_AUTHENTICATION_ERROR", "CONNECTION_FAILED_CONNECTION_ERROR", "CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", "CONNECTION_FAILED_QUOTA_ERROR", "CONNECTION_FAILED_UNKNOWN_ERROR"];
+export type ImapConnectionStatus = (typeof IMAP_CONNECTION_STATUSES)[number];
+//# sourceMappingURL=ImapConnectionStatus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImapConnectionStatus.d.ts","sourceRoot":"","sources":["../../src/types/ImapConnectionStatus.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,6OAQ3B,CAAA;AAEV,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/ImapConnectionStatus.js

@@ -0,0 +1,9 @@
+export const IMAP_CONNECTION_STATUSES = [
+    'AWAITING_CONNECTION',
+    'CONNECTED',
+    'CONNECTION_FAILED_AUTHENTICATION_ERROR',
+    'CONNECTION_FAILED_CONNECTION_ERROR',
+    'CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR',
+    'CONNECTION_FAILED_QUOTA_ERROR',
+    'CONNECTION_FAILED_UNKNOWN_ERROR',
+];

package/dist/types/LabelSpecialUse.d.ts

@@ -0,0 +1,3 @@
+export declare const LABEL_SPECIAL_USES: readonly ["ARCHIVE", "INBOX", "SENT", "SPAM", "TRASH"];
+export type LabelSpecialUse = (typeof LABEL_SPECIAL_USES)[number];
+//# sourceMappingURL=LabelSpecialUse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LabelSpecialUse.d.ts","sourceRoot":"","sources":["../../src/types/LabelSpecialUse.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,wDAAyD,CAAA;AAExF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/LabelSpecialUse.js

@@ -0,0 +1 @@
+export const LABEL_SPECIAL_USES = ['ARCHIVE', 'INBOX', 'SENT', 'SPAM', 'TRASH'];

package/dist/types/MessageAttachmentStatus.d.ts

@@ -0,0 +1,3 @@
+export declare const MESSAGE_ATTACHMENT_STATUSES: readonly ["NOT_DOWNLOADED", "DOWNLOAD_REQUESTED", "DOWNLOADED", "DOWNLOAD_FAILED"];
+export type MessageAttachmentStatus = (typeof MESSAGE_ATTACHMENT_STATUSES)[number];
+//# sourceMappingURL=MessageAttachmentStatus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MessageAttachmentStatus.d.ts","sourceRoot":"","sources":["../../src/types/MessageAttachmentStatus.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,oFAK9B,CAAA;AAEV,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/MessageAttachmentStatus.js

@@ -0,0 +1,6 @@
+export const MESSAGE_ATTACHMENT_STATUSES = [
+    'NOT_DOWNLOADED',
+    'DOWNLOAD_REQUESTED',
+    'DOWNLOADED',
+    'DOWNLOAD_FAILED',
+];

package/dist/types/MessageRecipientType.d.ts

@@ -0,0 +1,3 @@
+export declare const MESSAGE_RECIPIENT_TYPES: readonly ["bcc", "cc", "to", "replyTo"];
+export type MessageRecipientType = (typeof MESSAGE_RECIPIENT_TYPES)[number];
+//# sourceMappingURL=MessageRecipientType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MessageRecipientType.d.ts","sourceRoot":"","sources":["../../src/types/MessageRecipientType.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,yCAA0C,CAAA;AAE9E,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/MessageRecipientType.js

@@ -0,0 +1 @@
+export const MESSAGE_RECIPIENT_TYPES = ['bcc', 'cc', 'to', 'replyTo'];

package/dist/types/index.d.ts

@@ -1,3 +1,10 @@
+export * from './DraftRecipientType';
+export * from './DraftStatus';
+export * from './DraftType';
 export * from './EmailProvider';
 export * from './Endpoint';
+export * from './ImapConnectionStatus';
+export * from './LabelSpecialUse';
+export * from './MessageAttachmentStatus';
+export * from './MessageRecipientType';
 //# 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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,2BAA2B,CAAA;AACzC,cAAc,wBAAwB,CAAA"}

package/dist/types/index.js

@@ -1,2 +1,9 @@
+export * from './DraftRecipientType';
+export * from './DraftStatus';
+export * from './DraftType';
 export * from './EmailProvider';
 export * from './Endpoint';
+export * from './ImapConnectionStatus';
+export * from './LabelSpecialUse';
+export * from './MessageAttachmentStatus';
+export * from './MessageRecipientType';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "2.0.409",
+  "version": "2.0.410",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",
@@ -31,6 +31,7 @@
   "devDependencies": {
     "@auto-it/npm": "11.2.0",
     "@biomejs/biome": "2.3.0",
+    "@instantdb/admin": "0.22.41",
     "@types/bun": "1.3.0",
     "auto": "11.2.0",
     "tsc-alias": "1.8.16",