@marcoappio/marco-config 2.0.407 → 2.0.409

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

@@ -1 +0,0 @@
-{"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/index.js

@@ -1,13 +0,0 @@
-import { account } from './account';
-import { contact } from './contact';
-import { draft } from './draft';
-import { thread } from './thread';
-import { user } from './user';
-export { marcoClientsUtils } from './utils';
-export const marcoClients = {
-    account,
-    contact,
-    draft,
-    thread,
-    user,
-};

package/dist/clients/thread.d.ts

@@ -1,134 +0,0 @@
-import * as v from 'valibot';
-export declare const thread: {
-    model: v.ObjectSchema<{
-        readonly bagOfWords: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly flagged: v.NonOptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly messages: v.ArraySchema<v.ObjectSchema<{
-            readonly attachments: v.ArraySchema<v.ObjectSchema<{
-                readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly size: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                readonly status: v.UnionSchema<[v.LiteralSchema<"NOT_DOWNLOADED", undefined>, v.LiteralSchema<"DOWNLOAD_REQUESTED", undefined>, v.LiteralSchema<"DOWNLOADED", undefined>, v.LiteralSchema<"DOWNLOAD_FAILED", undefined>], undefined>;
-            }, undefined>, undefined>;
-            readonly bcc: v.ArraySchema<v.ObjectSchema<{
-                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, undefined>;
-            readonly cc: v.ArraySchema<v.ObjectSchema<{
-                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, undefined>;
-            readonly envelopeDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            readonly envelopeSubject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly from: v.ObjectSchema<{
-                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>;
-            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly labelIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            readonly previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly replyTo: v.ArraySchema<v.ObjectSchema<{
-                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, undefined>;
-            readonly to: v.ArraySchema<v.ObjectSchema<{
-                readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, undefined>;
-        }, undefined>, undefined>;
-        readonly seen: v.NonOptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    }, undefined>;
-    mutators: {
-        addLabel: {
-            delta: v.ObjectSchema<{
-                readonly labelPath: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>;
-        };
-        delete: {
-            delta: v.UnionSchema<[v.ObjectSchema<{
-                readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
-        };
-        removeLabel: {
-            delta: v.ObjectSchema<{
-                readonly labelPath: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>;
-        };
-        requestAttachmentDownload: {
-            delta: v.UnionSchema<readonly [v.ObjectSchema<{
-                readonly attachmentId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly attachmentIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
-        };
-        setFlagged: {
-            delta: v.UnionSchema<readonly [v.ObjectSchema<{
-                readonly flagged: v.NonOptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly flagged: v.NonOptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
-        };
-        setLabels: {
-            delta: v.UnionSchema<readonly [v.ObjectSchema<{
-                readonly labelIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly labelIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
-        };
-        setSeen: {
-            delta: v.UnionSchema<readonly [v.ObjectSchema<{
-                readonly seen: v.BooleanSchema<undefined>;
-                readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly seen: v.BooleanSchema<undefined>;
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
-        };
-        setArchive: {
-            delta: v.UnionSchema<[v.ObjectSchema<{
-                readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
-        };
-        setInbox: {
-            delta: v.UnionSchema<[v.ObjectSchema<{
-                readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
-        };
-        setSpam: {
-            delta: v.UnionSchema<[v.ObjectSchema<{
-                readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
-        };
-        setTrash: {
-            delta: v.UnionSchema<[v.ObjectSchema<{
-                readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>], undefined>;
-        };
-    };
-    name: "thread";
-    pullUrl: "/v1/pv/sync/pull/thread";
-    pushUrl: "/v1/pv/sync/push/thread";
-    schemaVersion: "v1";
-};
-//# sourceMappingURL=thread.d.ts.map

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

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

package/dist/clients/thread.js

@@ -1,134 +0,0 @@
-import * as v from 'valibot';
-import { marcoConstants } from '../constants';
-import { marcoSchemas } from '../schemas';
-const inlineContact = v.object({
-    emailAddress: marcoSchemas.string.email(),
-    name: marcoSchemas.string.nullable(),
-});
-const inlineAttachment = v.object({
-    fileName: marcoSchemas.string.required(),
-    id: marcoSchemas.string.required(),
-    mimeType: marcoSchemas.string.required(),
-    size: marcoSchemas.number.positiveInteger(),
-    status: v.union([
-        v.literal('NOT_DOWNLOADED'),
-        v.literal('DOWNLOAD_REQUESTED'),
-        v.literal('DOWNLOADED'),
-        v.literal('DOWNLOAD_FAILED'),
-    ]),
-});
-const threadIdOrIdArraySchema = v.union([
-    v.object({
-        threadId: marcoSchemas.string.required(),
-    }),
-    v.object({
-        threadIds: v.array(marcoSchemas.string.required()),
-    }),
-]);
-const specialUseMutators = {
-    setArchive: {
-        delta: threadIdOrIdArraySchema,
-    },
-    setInbox: {
-        delta: threadIdOrIdArraySchema,
-    },
-    setSpam: {
-        delta: threadIdOrIdArraySchema,
-    },
-    setTrash: {
-        delta: threadIdOrIdArraySchema,
-    },
-};
-export const thread = {
-    model: v.object({
-        bagOfWords: v.array(marcoSchemas.string.required()),
-        emailAccountId: marcoSchemas.string.required(),
-        flagged: v.nonOptional(v.boolean()),
-        id: marcoSchemas.string.required(),
-        messages: v.array(v.object({
-            attachments: v.array(inlineAttachment),
-            bcc: v.array(inlineContact),
-            cc: v.array(inlineContact),
-            envelopeDate: marcoSchemas.number.positiveInteger(),
-            envelopeSubject: marcoSchemas.string.nullable(),
-            from: inlineContact,
-            id: marcoSchemas.string.required(),
-            labelIds: v.array(marcoSchemas.string.required()),
-            previewText: marcoSchemas.string.required(marcoConstants.messages.PREVIEW_TEXT_MAX_LENGTH),
-            replyTo: v.array(inlineContact),
-            to: v.array(inlineContact),
-        })),
-        seen: v.nonOptional(v.boolean()),
-    }),
-    mutators: {
-        ...specialUseMutators,
-        addLabel: {
-            delta: v.object({
-                labelPath: marcoSchemas.string.required(),
-                threadIds: v.array(marcoSchemas.string.required()),
-            }),
-        },
-        delete: {
-            delta: threadIdOrIdArraySchema,
-        },
-        removeLabel: {
-            delta: v.object({
-                labelPath: marcoSchemas.string.required(),
-                threadIds: v.array(marcoSchemas.string.required()),
-            }),
-        },
-        requestAttachmentDownload: {
-            delta: v.union([
-                v.object({
-                    attachmentId: marcoSchemas.string.required(),
-                    threadId: marcoSchemas.string.required(),
-                }),
-                v.object({
-                    attachmentIds: v.array(marcoSchemas.string.required()),
-                    threadIds: v.array(marcoSchemas.string.required()),
-                }),
-            ]),
-        },
-        setFlagged: {
-            delta: v.union([
-                v.object({
-                    flagged: v.nonOptional(v.boolean()),
-                    threadId: marcoSchemas.string.required(),
-                }),
-                v.object({
-                    flagged: v.nonOptional(v.boolean()),
-                    threadIds: v.array(marcoSchemas.string.required()),
-                }),
-            ]),
-        },
-        // DEPRECATED
-        setLabels: {
-            delta: v.union([
-                v.object({
-                    labelIds: v.array(marcoSchemas.string.required()),
-                    threadId: marcoSchemas.string.required(),
-                }),
-                v.object({
-                    labelIds: v.array(marcoSchemas.string.required()),
-                    threadIds: v.array(marcoSchemas.string.required()),
-                }),
-            ]),
-        },
-        setSeen: {
-            delta: v.union([
-                v.object({
-                    seen: v.boolean(),
-                    threadId: marcoSchemas.string.required(),
-                }),
-                v.object({
-                    seen: v.boolean(),
-                    threadIds: v.array(marcoSchemas.string.required()),
-                }),
-            ]),
-        },
-    },
-    name: 'thread',
-    pullUrl: '/v1/pv/sync/pull/thread',
-    pushUrl: '/v1/pv/sync/push/thread',
-    schemaVersion: 'v1',
-};

package/dist/clients/user.d.ts

@@ -1,53 +0,0 @@
-import * as v from 'valibot';
-export declare const user: {
-    model: v.ObjectSchema<{
-        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly settings: v.ObjectSchema<{
-            readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly notifications: v.ObjectSchema<{
-                readonly pushNotificationTokens: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
-                    readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                    readonly deviceId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                    readonly token: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                }, undefined>, undefined>;
-            }, undefined>;
-            readonly profilePicture: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly undoSendEnabled: v.BooleanSchema<undefined>;
-        }, undefined>;
-    }, undefined>;
-    mutators: {
-        deleteSettingsPushNotificationToken: {
-            delta: v.ObjectSchema<{
-                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly token: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>;
-        };
-        deleteSettingsPushNotificationTokenForDevice: {
-            delta: v.ObjectSchema<{
-                readonly deviceId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>;
-        };
-        setSettingsName: {
-            delta: v.ObjectSchema<{
-                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>;
-        };
-        setSettingsPushNotificationToken: {
-            delta: v.ObjectSchema<{
-                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly pushNotificationToken: v.ObjectSchema<{
-                    readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                    readonly deviceId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                    readonly token: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                }, undefined>;
-            }, undefined>;
-        };
-    };
-    name: "user";
-    pullUrl: "/v1/pv/sync/pull/user";
-    pushUrl: "/v1/pv/sync/push/user";
-    schemaVersion: "v1";
-};
-//# sourceMappingURL=user.d.ts.map

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

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

package/dist/clients/user.js

@@ -1,52 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../schemas';
-const pushNotificationToken = v.object({
-    createdAt: marcoSchemas.number.positiveInteger(),
-    deviceId: marcoSchemas.string.required(),
-    token: marcoSchemas.string.required(),
-});
-const pushNotificationTokens = v.record(marcoSchemas.string.required(), pushNotificationToken);
-const userSettings = v.object({
-    name: marcoSchemas.string.nullable(),
-    notifications: v.object({
-        pushNotificationTokens,
-    }),
-    profilePicture: marcoSchemas.string.nullable(),
-    undoSendEnabled: v.boolean(),
-});
-export const user = {
-    model: v.object({
-        id: marcoSchemas.string.required(),
-        settings: userSettings,
-    }),
-    mutators: {
-        deleteSettingsPushNotificationToken: {
-            delta: v.object({
-                id: marcoSchemas.string.required(),
-                token: marcoSchemas.string.required(),
-            }),
-        },
-        deleteSettingsPushNotificationTokenForDevice: {
-            delta: v.object({
-                deviceId: marcoSchemas.string.required(),
-                id: marcoSchemas.string.required(),
-            }),
-        },
-        setSettingsName: {
-            delta: v.object({
-                id: marcoSchemas.string.required(),
-                name: marcoSchemas.string.nullable(),
-            }),
-        },
-        setSettingsPushNotificationToken: {
-            delta: v.object({
-                id: marcoSchemas.string.required(),
-                pushNotificationToken,
-            }),
-        },
-    },
-    name: 'user',
-    pullUrl: '/v1/pv/sync/pull/user',
-    pushUrl: '/v1/pv/sync/push/user',
-    schemaVersion: 'v1',
-};

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

@@ -1,4 +0,0 @@
-export declare const marcoClientsUtils: {
-    labelSpecialUseOrdering: ("ARCHIVE" | "INBOX" | "SENT" | "SPAM" | "TRASH")[];
-};
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/clients/utils/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;CAE7B,CAAA"}

package/dist/clients/utils/index.js

@@ -1,4 +0,0 @@
-import { labelSpecialUseOrdering } from './labelSpecialUseOrdering';
-export const marcoClientsUtils = {
-    labelSpecialUseOrdering,
-};

package/dist/clients/utils/labelSpecialUseOrdering.d.ts

@@ -1,3 +0,0 @@
-import { LabelSpecialUse } from '../../types';
-export declare const labelSpecialUseOrdering: LabelSpecialUse[];
-//# sourceMappingURL=labelSpecialUseOrdering.d.ts.map

package/dist/clients/utils/labelSpecialUseOrdering.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"labelSpecialUseOrdering.d.ts","sourceRoot":"","sources":["../../../src/clients/utils/labelSpecialUseOrdering.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAErD,eAAO,MAAM,uBAAuB,EAAE,eAAe,EAMpD,CAAA"}

package/dist/clients/utils/labelSpecialUseOrdering.js

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

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.d.ts

@@ -1,21 +0,0 @@
-import * as v from 'valibot';
-export declare const getEmailMessageAttachment: import("../../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", v.GenericSchema | undefined, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"ATTACHMENT_NOT_FOUND", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"ATTACHMENT_STATE_INVALID", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<409, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly file: v.NonOptionalSchema<v.FileSchema<undefined>, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=getEmailMessageAttachment.d.ts.map

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEmailMessageAttachment.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;2BAYpC,CAAA"}

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.js

@@ -1,16 +0,0 @@
-import * as v from 'valibot';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { attachmentNotFoundErrorSchema, attachmentStateInvalidErrorSchema, authFailedErrorSchema } from '../../../../sdk/validation/errors';
-export const getEmailMessageAttachment = createEndpoint({
-    method: 'GET',
-    path: '/v1/pv/attachment/:attachmentId',
-    response: v.union([
-        authFailedErrorSchema,
-        attachmentNotFoundErrorSchema,
-        attachmentStateInvalidErrorSchema,
-        v.object({
-            file: v.nonOptional(v.file()),
-            status: v.literal(200),
-        }),
-    ]),
-});

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageHTML.d.ts

@@ -1,19 +0,0 @@
-import * as v from 'valibot';
-export declare const getEmailMessageHTML: import("../../../..").EndpointConfig<"/v1/pv/message/:messageId/html", v.GenericSchema | undefined, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly content: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
-        readonly html: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=getEmailMessageHTML.d.ts.map

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageHTML.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEmailMessageHTML.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/emailMessage/getEmailMessageHTML.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;2BAc9B,CAAA"}

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageHTML.js

@@ -1,19 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../schemas';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { authFailedErrorSchema, messageNotFoundErrorSchema } from '../../../../sdk/validation/errors';
-export const getEmailMessageHTML = createEndpoint({
-    method: 'GET',
-    path: '/v1/pv/message/:messageId/html',
-    response: v.union([
-        authFailedErrorSchema,
-        messageNotFoundErrorSchema,
-        v.object({
-            data: v.object({
-                content: v.record(v.string(), v.string()),
-                html: marcoSchemas.string.required(),
-            }),
-            status: v.literal(200),
-        }),
-    ]),
-});

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

@@ -1,39 +0,0 @@
-export declare const emailMessage: {
-    getAttachment: import("../../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"ATTACHMENT_NOT_FOUND", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<404, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"ATTACHMENT_STATE_INVALID", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<409, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly file: import("valibot").NonOptionalSchema<import("valibot").FileSchema<undefined>, undefined>;
-        readonly status: import("valibot").LiteralSchema<200, undefined>;
-    }, undefined>], undefined>>;
-    getHTML: import("../../../..").EndpointConfig<"/v1/pv/message/:messageId/html", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<404, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly content: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").StringSchema<undefined>, undefined>;
-            readonly html: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<200, undefined>;
-    }, undefined>], undefined>>;
-};
-//# sourceMappingURL=index.d.ts.map

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

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

package/dist/sdk/endpoints/private/emailMessage/index.js

@@ -1,6 +0,0 @@
-import { getEmailMessageAttachment } from './getEmailMessageAttachment';
-import { getEmailMessageHTML } from './getEmailMessageHTML';
-export const emailMessage = {
-    getAttachment: getEmailMessageAttachment,
-    getHTML: getEmailMessageHTML,
-};