@marcoappio/marco-config 2.0.415 → 2.0.417

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,125 +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.PicklistSchema<readonly ["NOT_DOWNLOADED", "DOWNLOAD_REQUESTED", "DOWNLOADED", "DOWNLOAD_FAILED"], 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>;
-        };
-        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;AA6C5B,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFI,CAAA"}

package/dist/clients/thread.js

@@ -1,117 +0,0 @@
-import * as v from 'valibot';
-import { marcoConstants } from '../constants';
-import { marcoSchemas } from '../schemas';
-import { MESSAGE_ATTACHMENT_STATUSES } from '../types';
-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.picklist(MESSAGE_ATTACHMENT_STATUSES),
-});
-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()),
-                }),
-            ]),
-        },
-        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;AAsB5B,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 type { 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,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,eAAO,MAAM,uBAAuB,EAAE,eAAe,EAAkD,CAAA"}

package/dist/clients/utils/labelSpecialUseOrdering.js

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