@marcoappio/marco-config 2.0.103 → 2.0.105

package/dist/clients/account.d.ts

@@ -0,0 +1,30 @@
+import * as v from 'valibot';
+export declare const account: {
+    model: v.ObjectSchema<{
+        readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly imapPasswordConfig: v.NullableSchema<v.ObjectSchema<{
+            readonly host: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly password: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly port: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
+            readonly status: v.UnionSchema<[v.LiteralSchema<"awaiting-connection", undefined>, v.LiteralSchema<"connected", undefined>, v.LiteralSchema<"disconnected", undefined>], undefined>;
+        }, undefined>, never>;
+        readonly labels: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly name: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly path: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    mutators: {
+        delete: {
+            delta: v.ObjectSchema<{
+                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>;
+        };
+    };
+    name: "account";
+    pullURL: "/v1/pv/sync/pull/account";
+    pushURL: "/v1/pv/sync/push/account";
+    schemaVersion: "v1";
+};
+//# sourceMappingURL=account.d.ts.map

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

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

package/dist/clients/account.js

@@ -0,0 +1,34 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../schemas';
+export const account = {
+    model: v.object({
+        emailAddress: marcoSchemas.string.email(),
+        id: marcoSchemas.string.required(),
+        imapPasswordConfig: v.nullable(v.object({
+            host: marcoSchemas.string.required(),
+            password: marcoSchemas.string.required(),
+            port: marcoSchemas.number.minMax(1, 65535),
+            status: v.union([
+                v.literal('awaiting-connection'),
+                v.literal('connected'),
+                v.literal('disconnected'),
+            ]),
+        })),
+        labels: v.array(v.object({
+            id: marcoSchemas.string.required(),
+            name: marcoSchemas.string.required(),
+            path: marcoSchemas.string.required(),
+        })),
+    }),
+    mutators: {
+        delete: {
+            delta: v.object({
+                id: marcoSchemas.string.required(),
+            }),
+        },
+    },
+    name: 'account',
+    pullURL: '/v1/pv/sync/pull/account',
+    pushURL: '/v1/pv/sync/push/account',
+    schemaVersion: 'v1',
+};

package/dist/clients/contact.d.ts

@@ -0,0 +1,15 @@
+import * as v from 'valibot';
+export declare const contact: {
+    model: v.ObjectSchema<{
+        readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly name: v.NullableSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, never>;
+    }, undefined>;
+    mutators: {};
+    name: "contact";
+    pullURL: "/v1/pv/sync/pull/contact";
+    pushURL: null;
+    schemaVersion: "v1";
+};
+//# sourceMappingURL=contact.d.ts.map

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

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

package/dist/clients/contact.js

@@ -0,0 +1,15 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../schemas';
+export const contact = {
+    model: v.object({
+        emailAccountId: marcoSchemas.string.required(),
+        emailAddress: marcoSchemas.string.email(),
+        id: marcoSchemas.string.required(),
+        name: marcoSchemas.string.nullable(),
+    }),
+    mutators: {},
+    name: 'contact',
+    pullURL: '/v1/pv/sync/pull/contact',
+    pushURL: null,
+    schemaVersion: 'v1',
+};

package/dist/clients/index.d.ts

@@ -0,0 +1,69 @@
+export declare const marcoClients: {
+    account: {
+        model: import("valibot").ObjectSchema<{
+            readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly imapPasswordConfig: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                readonly host: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly password: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly port: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
+                readonly status: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"awaiting-connection", undefined>, import("valibot").LiteralSchema<"connected", undefined>, import("valibot").LiteralSchema<"disconnected", undefined>], undefined>;
+            }, undefined>, never>;
+            readonly labels: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly path: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+        mutators: {
+            delete: {
+                delta: import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                }, undefined>;
+            };
+        };
+        name: "account";
+        pullURL: "/v1/pv/sync/pull/account";
+        pushURL: "/v1/pv/sync/push/account";
+        schemaVersion: "v1";
+    };
+    contact: {
+        model: import("valibot").ObjectSchema<{
+            readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly emailAddress: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, never>;
+        }, undefined>;
+        mutators: {};
+        name: "contact";
+        pullURL: "/v1/pv/sync/pull/contact";
+        pushURL: null;
+        schemaVersion: "v1";
+    };
+    thread: {
+        model: import("valibot").ObjectSchema<{
+            readonly emailAccountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly messages: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly bccIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly ccIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly envelopeDate: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly envelopeSubject: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly fromId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly isFlagged: import("valibot").BooleanSchema<undefined>;
+                readonly isSeen: import("valibot").BooleanSchema<undefined>;
+                readonly labelIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly previewText: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly replyToIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+                readonly toIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+        mutators: {};
+        name: "thread";
+        pullURL: "/v1/pv/sync/pull/thread";
+        pushURL: "/v1/pv/sync/push/thread";
+        schemaVersion: "v1";
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/clients/index.js

@@ -0,0 +1,8 @@
+import { account } from './account';
+import { contact } from './contact';
+import { thread } from './thread';
+export const marcoClients = {
+    account,
+    contact,
+    thread,
+};

package/dist/clients/thread.d.ts

@@ -0,0 +1,27 @@
+import * as v from 'valibot';
+export declare const thread: {
+    model: v.ObjectSchema<{
+        readonly emailAccountId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+        readonly messages: v.ArraySchema<v.ObjectSchema<{
+            readonly bccIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly ccIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly envelopeDate: v.NonOptionalSchema<v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly envelopeSubject: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly fromId: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly isFlagged: v.BooleanSchema<undefined>;
+            readonly isSeen: v.BooleanSchema<undefined>;
+            readonly labelIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly previewText: v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
+            readonly replyToIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+            readonly toIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    mutators: {};
+    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

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

package/dist/clients/thread.js

@@ -0,0 +1,27 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../schemas';
+export const thread = {
+    model: v.object({
+        emailAccountId: marcoSchemas.string.required(),
+        id: marcoSchemas.string.required(),
+        messages: v.array(v.object({
+            bccIds: v.array(marcoSchemas.string.required()),
+            ccIds: v.array(marcoSchemas.string.required()),
+            envelopeDate: marcoSchemas.number.positiveInteger(),
+            envelopeSubject: marcoSchemas.string.required(),
+            fromId: marcoSchemas.string.required(),
+            id: marcoSchemas.string.required(),
+            isFlagged: v.boolean(),
+            isSeen: v.boolean(),
+            labelIds: v.array(marcoSchemas.string.required()),
+            previewText: marcoSchemas.string.required(),
+            replyToIds: v.array(marcoSchemas.string.required()),
+            toIds: v.array(marcoSchemas.string.required()),
+        })),
+    }),
+    mutators: {},
+    name: 'thread',
+    pullURL: '/v1/pv/sync/pull/thread',
+    pushURL: '/v1/pv/sync/push/thread',
+    schemaVersion: 'v1',
+};

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export { MarcoClients } from './MarcoClients';
+export { marcoClients } from './clients';
 export { marcoPublicConfig, MARCO_ENV, MarcoEnvironment } from './marcoPublicConfig';
 export { marcoSDK } from './sdk';
-export { MarcoWSEvent, EmailContactType, EndpointConfig, EndpointError, EndpointResponse } from './types';
+export { MarcoWSEvent, MarcoClient, MarcoWSSyncPoke, EndpointConfig, EndpointError, EndpointResponse } from './types';
+export { marcoSchemas } from './schemas';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AACrH,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA"}

package/dist/index.js

@@ -1,3 +1,4 @@
+export { marcoClients } from './clients';
 export { marcoPublicConfig, MARCO_ENV } from './marcoPublicConfig';
 export { marcoSDK } from './sdk';
-export { MarcoWSEvent, EmailContactType } from './types';
+export { marcoSchemas } from './schemas';

package/dist/{sdk/validation/schemas/schemas.d.ts → schemas.d.ts}

@@ -1,13 +1,15 @@
-export declare const schemas: {
+export declare const marcoSchemas: {
     number: {
         minMax: (min: number, max: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
+        positiveInteger: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
     };
     string: {
         email: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
         enum: (values: Record<string, string>) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EnumSchema<Record<string, string>, undefined>]>, undefined>;
         matches: (regex: RegExp) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, undefined>]>, undefined>;
-        optional: () => import("valibot").UndefinedableSchema<import("valibot").StringSchema<undefined>, never>;
-        required: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>]>, undefined>;
+        nullable: () => import("valibot").NullableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, never>;
+        optional: () => import("valibot").UndefinedableSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, never>;
+        required: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
     };
 };
 //# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;sBAEP,MAAM,OAAO,MAAM;;;;;uBAQlB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;yBAEpB,MAAM;;;;;CAS1B,CAAA"}

package/dist/schemas.js

@@ -0,0 +1,15 @@
+import { email, enum as enumValidator, integer, maxLength, maxValue, minValue, nonEmpty, nonOptional, nullable, number, pipe, string, undefinedable, regex as v_regex } from 'valibot';
+export const marcoSchemas = {
+    number: {
+        minMax: (min, max) => nonOptional(pipe(number(), minValue(min), maxValue(max))),
+        positiveInteger: () => nonOptional(pipe(number(), integer(), minValue(0))),
+    },
+    string: {
+        email: () => nonOptional(pipe(string(), email(), maxLength(255))),
+        enum: (values) => nonOptional(pipe(string(), enumValidator(values))),
+        matches: (regex) => nonOptional(pipe(string(), v_regex(regex))),
+        nullable: () => nullable(pipe(string(), maxLength(255))),
+        optional: () => undefinedable(pipe(string(), maxLength(255))),
+        required: () => nonOptional(pipe(string(), nonEmpty(), maxLength(255))),
+    },
+};

package/dist/sdk/endpoints/public/auth/sendAuthCode.js

@@ -1,11 +1,11 @@
 import * as v from 'valibot';
+import { marcoSchemas } from '../../../../schemas';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { validation } from '../../../../sdk/validation';
 import { errorManifest } from '../../../../sdk/validation/errors';
 import { HTTPMethod } from '../../../../types/Endpoint';
 export const sendAuthCode = createEndpoint({
     body: v.object({
-        email: validation.schemas.string.email(),
+        email: marcoSchemas.string.email(),
     }),
     method: HTTPMethod.POST,
     path: '/v1/pb/auth/send-code',

package/dist/sdk/endpoints/public/auth/verifyAuthCode.js

@@ -1,12 +1,12 @@
 import * as v from 'valibot';
+import { marcoSchemas } from '../../../../schemas';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { validation } from '../../../../sdk/validation';
 import { errorManifest } from '../../../../sdk/validation/errors';
 import { HTTPMethod } from '../../../../types/Endpoint';
 export const verifyAuthCode = createEndpoint({
     body: v.object({
         code: v.string(),
-        email: validation.schemas.string.email(),
+        email: marcoSchemas.string.email(),
     }),
     method: HTTPMethod.POST,
     path: '/v1/pb/auth/verify-code',

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

@@ -0,0 +1,8 @@
+import * as v from 'valibot';
+export declare const healthcheck: import("../../../../types").EndpointConfig<"/v1/pb/healthcheck", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly status: v.LiteralSchema<"ok", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/endpoints/public/healthcheck/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/healthcheck/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,WAAW;;;;;cAOtB,CAAA"}

package/dist/sdk/endpoints/public/{healthcheck.js → healthcheck/index.js}

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
-import { createEndpoint } from '../../../sdk/endpoints/createEndpointConfig';
-import { HTTPMethod } from '../../../types';
+import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
+import { HTTPMethod } from '../../../../types';
 export const healthcheck = createEndpoint({
     method: HTTPMethod.GET,
     path: '/v1/pb/healthcheck',

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sdk/endpoints/public/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEvB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sdk/endpoints/public/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGvB,CAAA"}

package/dist/sdk/endpoints/public/index.js

@@ -1,5 +1,6 @@
 import { auth } from './auth';
 import { healthcheck } from './healthcheck';
 export const publicGroup = {
-    auth, healthcheck,
+    auth,
+    healthcheck,
 };

package/dist/sdk/index.d.ts

@@ -95,18 +95,6 @@ export declare const marcoSDK: {
         };
     };
     validation: {
-        schemas: {
-            number: {
-                minMax: (min: number, max: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-            };
-            string: {
-                email: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-                enum: (values: Record<string, string>) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EnumSchema<Record<string, string>, undefined>]>, undefined>;
-                matches: (regex: RegExp) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, undefined>]>, undefined>;
-                optional: () => import("valibot").UndefinedableSchema<import("valibot").StringSchema<undefined>, never>;
-                required: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>]>, undefined>;
-            };
-        };
         utils: {
             flattenRequirements: <T extends Record<string, any>>(schema: import("valibot").ObjectSchema<T, any>) => { [K in keyof T]: {
                 maxLength?: number;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAA"}

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

@@ -1,16 +1,4 @@
 export declare const validation: {
-    schemas: {
-        number: {
-            minMax: (min: number, max: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-        };
-        string: {
-            email: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-            enum: (values: Record<string, string>) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").EnumSchema<Record<string, string>, undefined>]>, undefined>;
-            matches: (regex: RegExp) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, undefined>]>, undefined>;
-            optional: () => import("valibot").UndefinedableSchema<import("valibot").StringSchema<undefined>, never>;
-            required: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>]>, undefined>;
-        };
-    };
     utils: {
         flattenRequirements: <T extends Record<string, any>>(schema: import("valibot").ObjectSchema<T, any>) => { [K in keyof T]: {
             maxLength?: number;

package/dist/sdk/validation/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;CAGtB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;CAEtB,CAAA"}

package/dist/sdk/validation/index.js

@@ -1,6 +1,4 @@
-import { schemas } from './schemas';
 import { utils } from './utils';
 export const validation = {
-    schemas,
     utils,
 };

package/dist/types/MarcoClient.d.ts

@@ -0,0 +1,12 @@
+import * as v from 'valibot';
+export type MarcoClient = {
+    model: v.ObjectSchema<any, any>;
+    mutators: Record<string, {
+        delta: v.ObjectSchema<any, any>;
+    }>;
+    name: string;
+    pullURL: string;
+    pushURL: string | null;
+    schemaVersion: string;
+};
+//# sourceMappingURL=MarcoClient.d.ts.map

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

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

package/dist/types/WS.d.ts

@@ -1,4 +1,9 @@
-export declare enum MarcoWSEvent {
-    CLIENT_DB_SYNC_REQUIRED = "CLIENT_DB_SYNC_REQUIRED"
-}
+import { marcoClients } from '../clients';
+export type MarcoWSSyncPoke = {
+    data: {
+        clientName: keyof typeof marcoClients;
+    };
+    event: 'SYNC_POKE';
+};
+export type MarcoWSEvent = MarcoWSSyncPoke;
 //# sourceMappingURL=WS.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"WS.d.ts","sourceRoot":"","sources":["../../src/types/WS.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY;IACtB,uBAAuB,4BAA4B;CACpD"}
+{"version":3,"file":"WS.d.ts","sourceRoot":"","sources":["../../src/types/WS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,OAAO,YAAY,CAAA;KACtC,CAAA;IACD,KAAK,EAAE,WAAW,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,eAAe,CAAA"}

package/dist/types/WS.js

@@ -1,4 +1 @@
-export var MarcoWSEvent;
-(function (MarcoWSEvent) {
-    MarcoWSEvent["CLIENT_DB_SYNC_REQUIRED"] = "CLIENT_DB_SYNC_REQUIRED";
-})(MarcoWSEvent || (MarcoWSEvent = {}));
+export {};

package/dist/types/index.d.ts

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

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

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

package/dist/types/index.js

@@ -1,3 +1,3 @@
-export * from './EmailContactType';
 export * from './Endpoint';
+export * from './MarcoClient';
 export * from './WS';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "2.0.103",
+  "version": "2.0.105",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",
@@ -30,7 +30,6 @@
     "eslint-plugin-sort-destructure-keys": "1.4.0",
     "eslint-plugin-sort-keys-fix": "1.1.2",
     "eslint-plugin-typescript-sort-keys": "2.3.0",
-    "type-fest": "4.30.0",
     "valibot": "0.42.1"
   },
   "devDependencies": {

package/dist/MarcoClients.d.ts

@@ -1,100 +0,0 @@
-import { ReadonlyDeep } from 'type-fest';
-export declare namespace MarcoClients {
-    namespace Account {
-        type Name = 'account';
-        type SchemaVersion = 'v1';
-        type Model = ReadonlyDeep<{
-            emailAddress: string;
-            id: string;
-            imapPasswordConfig: {
-                host: string;
-                password: string;
-                port: number;
-                status: 'awaiting-connection' | 'connected' | 'disconnected';
-            } | null;
-        }>;
-        type Mutators = {
-            delete: {
-                delta: Pick<Model, 'id'>;
-            };
-            setImapPasswordConfig: {
-                delta: Pick<Model, 'id'> & {
-                    imapPasswordConfig: Omit<Model['imapPasswordConfig'], 'status'>;
-                };
-            };
-        };
-        type PullURL = `/v1/pv/sync/pull/${Name}`;
-        type PushURL = `/v1/pv/sync/push/${Name}`;
-    }
-    namespace Contact {
-        type Name = 'contact';
-        type SchemaVersion = 'v1';
-        type Model = ReadonlyDeep<{
-            emailAccountId: string;
-            emailAddress: string;
-            id: string;
-            name: string;
-        }>;
-        type Mutators = Record<string, never>;
-        type PullURL = `/v1/pv/sync/pull/${Name}`;
-        type PushURL = undefined;
-    }
-    namespace Label {
-        type Name = 'label';
-        type SchemaVersion = 'v1';
-        type Model = ReadonlyDeep<{
-            emailAccountId: string;
-            id: string;
-            name: string;
-            path: string;
-        }>;
-        type Mutators = Record<string, never>;
-        type PullURL = `/v1/pv/sync/pull/${Name}`;
-        type PushURL = undefined;
-    }
-    namespace Message {
-        type Name = 'message';
-        type SchemaVersion = 'v1';
-        type Model = ReadonlyDeep<{
-            bccIds: string[];
-            ccIds: string[];
-            emailThreadId: string;
-            envelopeDate: string;
-            envelopeSubject: string;
-            fromId: string;
-            id: string;
-            isFlagged: boolean;
-            isSeen: boolean;
-            labelIds: string[];
-            previewText: string;
-            replyToIds: string[];
-            toIds: string[];
-        }>;
-        type Mutators = {
-            delete: {
-                delta: Pick<Model, 'id'>;
-            };
-            setSeen: {
-                delta: Pick<Model, 'id' | 'isSeen'>;
-            };
-        };
-        type PullURL = `/v1/pv/sync/pull/${Name}`;
-        type PushURL = `/v1/pv/sync/push/${Name}`;
-    }
-    namespace Thread {
-        type Name = 'thread';
-        type SchemaVersion = 'v1';
-        type Model = ReadonlyDeep<{
-            emailAccountId: string;
-            id: string;
-        }>;
-        type Mutators = {
-            delete: {
-                delta: Pick<Model, 'id'>;
-            };
-        };
-        type PullURL = `/v1/pv/sync/pull/${Name}`;
-        type PushURL = `/v1/pv/sync/push/${Name}`;
-    }
-}
-//# sourceMappingURL=MarcoClients.d.ts.map

package/dist/MarcoClients.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MarcoClients.d.ts","sourceRoot":"","sources":["../src/MarcoClients.ts"],"names":[],"mappings":"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"}

package/dist/sdk/endpoints/public/healthcheck.d.ts

@@ -1,8 +0,0 @@
-import * as v from 'valibot';
-export declare const healthcheck: import("../../../types").EndpointConfig<"/v1/pb/healthcheck", v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.GenericSchema<unknown, unknown, v.BaseIssue<unknown>> | undefined, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly status: v.LiteralSchema<"ok", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>>;
-//# sourceMappingURL=healthcheck.d.ts.map

package/dist/sdk/endpoints/public/healthcheck.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"healthcheck.d.ts","sourceRoot":"","sources":["../../../../src/sdk/endpoints/public/healthcheck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,WAAW;;;;;cAOtB,CAAA"}

package/dist/sdk/validation/schemas/index.d.ts

@@ -1,2 +0,0 @@
-export { schemas } from './schemas';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sdk/validation/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA"}

package/dist/sdk/validation/schemas/index.js

@@ -1 +0,0 @@
-export { schemas } from './schemas';

package/dist/sdk/validation/schemas/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/sdk/validation/schemas/schemas.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;sBAEF,MAAM,OAAO,MAAM;;;;uBAMlB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;yBAEpB,MAAM;;;;CAO1B,CAAA"}

package/dist/sdk/validation/schemas/schemas.js

@@ -1,13 +0,0 @@
-import { email, enum as enumValidator, maxLength, maxValue, minValue, nonEmpty, nonOptional, number, pipe, string, undefinedable, regex as v_regex } from 'valibot';
-export const schemas = {
-    number: {
-        minMax: (min, max) => nonOptional(pipe(number(), minValue(min), maxValue(max))),
-    },
-    string: {
-        email: () => nonOptional(pipe(string(), email(), maxLength(255))),
-        enum: (values) => nonOptional(pipe(string(), enumValidator(values))),
-        matches: (regex) => nonOptional(pipe(string(), v_regex(regex))),
-        optional: () => undefinedable(string()),
-        required: () => nonOptional(pipe(string(), nonEmpty())),
-    },
-};

package/dist/types/EmailContactType.d.ts

@@ -1,8 +0,0 @@
-export declare enum EmailContactType {
-    BCC = "bcc",
-    CC = "cc",
-    FROM = "from",
-    REPLY_TO = "reply_to",
-    TO = "to"
-}
-//# sourceMappingURL=EmailContactType.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"EmailContactType.d.ts","sourceRoot":"","sources":["../../src/types/EmailContactType.ts"],"names":[],"mappings":"AAAA,oBAAY,gBAAgB;IAC1B,GAAG,QAAQ;IACX,EAAE,OAAO;IACT,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,EAAE,OAAO;CACV"}

package/dist/types/EmailContactType.js

@@ -1,8 +0,0 @@
-export var EmailContactType;
-(function (EmailContactType) {
-    EmailContactType["BCC"] = "bcc";
-    EmailContactType["CC"] = "cc";
-    EmailContactType["FROM"] = "from";
-    EmailContactType["REPLY_TO"] = "reply_to";
-    EmailContactType["TO"] = "to";
-})(EmailContactType || (EmailContactType = {}));