@marcoappio/marco-config 4.0.15 → 4.0.17

package/dist/schemas/index.d.ts

@@ -2,7 +2,7 @@ export type { AccountId, AliasId, AttachmentId, ContactId, DraftId, JobId, Label
 export type { Account, AccountAlias, AccountLabel, Contact, Draft, DraftAttachment, DraftBody, Thread, ThreadMessage, ThreadMessageAttachment, ThreadMessageRecipient, UserView, } from './models';
 export declare const marcoSchemas: {
     app: {
-        platform: () => import("valibot").PicklistSchema<readonly ["ios", "osx", "web"], undefined>;
+        platform: import("valibot").PicklistSchema<readonly ["ios", "osx", "web"], undefined>;
     };
     auth: {
         code: import("valibot").ObjectSchema<{
@@ -12,7 +12,7 @@ export declare const marcoSchemas: {
         }, undefined>;
     };
     emailAccount: {
-        connectionConfigImapRaw: () => import("valibot").ObjectSchema<{
+        connectionConfigImapRaw: import("valibot").ObjectSchema<{
             readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly imapPassword: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly imapPort: import("valibot").SchemaWithPipe<readonly [import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>, import("valibot").MaxValueAction<number, 65535, undefined>]>;
@@ -24,13 +24,13 @@ export declare const marcoSchemas: {
             readonly smtpSocketType: import("valibot").PicklistSchema<readonly ["SSL", "STARTTLS"], undefined>;
             readonly smtpUser: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
-        connectionConfigOauth: () => import("valibot").ObjectSchema<{
+        connectionConfigOauth: import("valibot").ObjectSchema<{
             readonly code: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly provider: import("valibot").PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], undefined>;
             readonly user: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
-        imapConnectionStatus: () => import("valibot").PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "CONNECTION_FAILED_AUTHENTICATION_ERROR", "CONNECTION_FAILED_CONNECTION_ERROR", "CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", "CONNECTION_FAILED_QUOTA_ERROR", "CONNECTION_FAILED_UNKNOWN_ERROR"], undefined>;
-        socketTypeSchema: () => import("valibot").PicklistSchema<readonly ["SSL", "STARTTLS"], undefined>;
+        imapConnectionStatus: import("valibot").PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "CONNECTION_FAILED_AUTHENTICATION_ERROR", "CONNECTION_FAILED_CONNECTION_ERROR", "CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", "CONNECTION_FAILED_QUOTA_ERROR", "CONNECTION_FAILED_UNKNOWN_ERROR"], undefined>;
+        socketTypeSchema: import("valibot").PicklistSchema<readonly ["SSL", "STARTTLS"], undefined>;
     };
     id: {
         accountId: {
@@ -231,24 +231,6 @@ export declare const marcoSchemas: {
             readonly userId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "UserId">]>, undefined>;
             readonly words: import("valibot").StringSchema<undefined>;
         }, undefined>;
-        threadListSchema: import("valibot").ObjectSchema<{
-            accountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>;
-            flagged: import("valibot").BooleanSchema<undefined>;
-            hasAttachments: import("valibot").BooleanSchema<undefined>;
-            id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>;
-            labelIdList: import("valibot").StringSchema<undefined>;
-            latestMessageDate: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>, undefined>;
-            latestMessageId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "MessageId">]>, undefined>;
-            messageCount: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-            previewText: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            seen: import("valibot").BooleanSchema<undefined>;
-            senderEmail: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, import("valibot").MaxLengthAction<string, 320, undefined>]>, undefined>;
-            senderName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            snoozedUntil: import("valibot").NullableSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>, undefined>, undefined>;
-            subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            userId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "UserId">]>, undefined>;
-            words: import("valibot").StringSchema<undefined>;
-        }, undefined>;
         threadMessageAttachmentSchema: import("valibot").ObjectSchema<{
             readonly fileName: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AttachmentId">]>, undefined>;
@@ -308,7 +290,7 @@ export declare const marcoSchemas: {
         }, undefined>;
         userViewSchema: import("valibot").ObjectSchema<{
             readonly aliasIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AliasId">]>, undefined>, undefined>;
-            readonly icon: import("valibot").PicklistSchema<readonly [import("..").CustomViewIcon.AIRPLANE, import("..").CustomViewIcon.BELL, import("..").CustomViewIcon.BRIEFCASE, import("..").CustomViewIcon.CLOCK, import("..").CustomViewIcon.CREDIT_CARD, import("..").CustomViewIcon.HEART, import("..").CustomViewIcon.HOME, import("..").CustomViewIcon.KEY, import("..").CustomViewIcon.MOON, import("..").CustomViewIcon.PERSON, import("..").CustomViewIcon.SHOPPING_CART, import("..").CustomViewIcon.STAR], undefined>;
+            readonly icon: import("valibot").PicklistSchema<readonly import("..").CustomViewIcon[], undefined>;
             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ViewId">]>, undefined>;
             readonly name: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
@@ -319,16 +301,16 @@ export declare const marcoSchemas: {
         positiveInteger: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>, undefined>;
     };
     oauth: {
-        provider: () => import("valibot").PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], undefined>;
+        provider: import("valibot").PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], undefined>;
     };
     pushNotifications: {
-        payload: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        payload: import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly messageId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "MessageId">]>, undefined>;
                 readonly threadId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>;
             }, undefined>;
             readonly event: import("valibot").LiteralSchema<"EMAIL_RECEIVED", undefined>;
-        }, undefined>], undefined>;
+        }, undefined>;
     };
     string: {
         email: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAyBA,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC3K,YAAY,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,KAAK,EACL,eAAe,EACf,SAAS,EACT,MAAM,EACN,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,QAAQ,GACT,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAwBA,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC3K,YAAY,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,KAAK,EACL,eAAe,EACf,SAAS,EACT,MAAM,EACN,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,QAAQ,GACT,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBxB,CAAA"}

package/dist/schemas/index.js

@@ -2,7 +2,7 @@ import { app } from './app';
 import { auth } from './auth';
 import { emailAccount } from './emailAccount';
 import { id } from './id';
-import { accountAliasSchema, accountLabelSchema, accountSchema, contactSchema, draftAttachmentSchema, draftBodySchema, draftSchema, threadFullSchema, threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, userViewSchema, } from './models';
+import { accountAliasSchema, accountLabelSchema, accountSchema, contactSchema, draftAttachmentSchema, draftBodySchema, draftSchema, threadFullSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, userViewSchema, } from './models';
 import { number } from './number';
 import { oauth } from './oauth';
 import { pushNotifications } from './pushNotifications';
@@ -21,7 +21,6 @@ export const marcoSchemas = {
         draftBodySchema,
         draftSchema,
         threadFullSchema,
-        threadListSchema,
         threadMessageAttachmentSchema,
         threadMessageRecipientSchema,
         threadMessageSchema,

package/dist/schemas/models/index.d.ts

@@ -1,6 +1,6 @@
 export { type Account, type AccountAlias, type AccountLabel, accountAliasSchema, accountLabelSchema, accountSchema } from './account';
 export { type Contact, contactSchema } from './contact';
 export { type Draft, type DraftAttachment, type DraftBody, draftAttachmentSchema, draftBodySchema, draftSchema } from './draft';
-export { type Thread, type ThreadMessage, type ThreadMessageAttachment, type ThreadMessageRecipient, threadFullSchema, threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, } from './thread';
+export { type Thread, type ThreadMessage, type ThreadMessageAttachment, type ThreadMessageRecipient, threadFullSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, } from './thread';
 export { type UserView, userViewSchema } from './user';
 //# sourceMappingURL=index.d.ts.map

package/dist/schemas/models/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/models/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACrI,OAAO,EAAE,KAAK,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAE,qBAAqB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAC/H,OAAO,EACL,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,gBAAgB,EAChB,6BAA6B,EAC7B,4BAA4B,EAC5B,mBAAmB,EACnB,YAAY,GACb,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/models/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACrI,OAAO,EAAE,KAAK,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAE,qBAAqB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAC/H,OAAO,EACL,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,6BAA6B,EAC7B,4BAA4B,EAC5B,mBAAmB,EACnB,YAAY,GACb,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA"}

package/dist/schemas/models/index.js

@@ -1,5 +1,5 @@
 export { accountAliasSchema, accountLabelSchema, accountSchema } from './account';
 export { contactSchema } from './contact';
 export { draftAttachmentSchema, draftBodySchema, draftSchema } from './draft';
-export { threadFullSchema, threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, } from './thread';
+export { threadFullSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, } from './thread';
 export { userViewSchema } from './user';

package/dist/schemas/models/thread.d.ts

@@ -56,24 +56,6 @@ export declare const threadSchema: v.ObjectSchema<{
     userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
     words: v.StringSchema<undefined>;
 }, undefined>;
-export declare const threadListSchema: v.ObjectSchema<{
-    accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
-    flagged: v.BooleanSchema<undefined>;
-    hasAttachments: v.BooleanSchema<undefined>;
-    id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>;
-    labelIdList: v.StringSchema<undefined>;
-    latestMessageDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
-    latestMessageId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
-    messageCount: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-    previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    seen: v.BooleanSchema<undefined>;
-    senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, v.MaxLengthAction<string, 320, undefined>]>, undefined>;
-    senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    snoozedUntil: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>, undefined>;
-    subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
-    words: v.StringSchema<undefined>;
-}, undefined>;
 export declare const threadFullSchema: v.ObjectSchema<{
     readonly messages: v.ArraySchema<v.ObjectSchema<{
         readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
@@ -118,7 +100,7 @@ export declare const threadFullSchema: v.ObjectSchema<{
     readonly words: v.StringSchema<undefined>;
 }, undefined>;
 export type Thread = v.InferOutput<typeof threadFullSchema>;
-export type ThreadListItem = v.InferOutput<typeof threadListSchema>;
+export type ThreadListItem = v.InferOutput<typeof threadSchema>;
 export type ThreadMessage = v.InferOutput<typeof threadMessageSchema>;
 export type ThreadMessageAttachment = v.InferOutput<typeof threadMessageAttachmentSchema>;
 export type ThreadMessageRecipient = v.InferOutput<typeof threadMessageRecipientSchema>;

package/dist/schemas/models/thread.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../../src/schemas/models/thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAQ5B,eAAO,MAAM,6BAA6B;;;;;;aAMxC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;aAMvC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;aAY9B,CAAA;AAqBF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;aAA8B,CAAA;AAEvD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;aAAe,CAAA;AAE5C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAG3B,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACnE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAA;AACzF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAA"}
+{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../../src/schemas/models/thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAQ5B,eAAO,MAAM,6BAA6B;;;;;;aAMxC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;aAMvC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;aAY9B,CAAA;AAqBF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;aAA8B,CAAA;AAEvD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAG3B,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,YAAY,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAA;AACzF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAA"}

package/dist/schemas/models/thread.js

@@ -50,7 +50,6 @@ const threadBaseEntries = {
     words: v.string(),
 };
 export const threadSchema = v.object(threadBaseEntries);
-export const threadListSchema = threadSchema;
 export const threadFullSchema = v.object({
     ...threadBaseEntries,
     messages: v.array(threadMessageSchema),

package/dist/schemas/models/user.d.ts

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 export declare const userViewSchema: v.ObjectSchema<{
     readonly aliasIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>, undefined>;
-    readonly icon: v.PicklistSchema<readonly [import("../../types").CustomViewIcon.AIRPLANE, import("../../types").CustomViewIcon.BELL, import("../../types").CustomViewIcon.BRIEFCASE, import("../../types").CustomViewIcon.CLOCK, import("../../types").CustomViewIcon.CREDIT_CARD, import("../../types").CustomViewIcon.HEART, import("../../types").CustomViewIcon.HOME, import("../../types").CustomViewIcon.KEY, import("../../types").CustomViewIcon.MOON, import("../../types").CustomViewIcon.PERSON, import("../../types").CustomViewIcon.SHOPPING_CART, import("../../types").CustomViewIcon.STAR], undefined>;
+    readonly icon: v.PicklistSchema<readonly import("../../types").CustomViewIcon[], undefined>;
     readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ViewId">]>, undefined>;
     readonly name: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
 }, undefined>;

package/dist/schemas/models/user.test.js

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'bun:test';
 import * as v from 'valibot';
+import { CustomViewIcon, USER_SETTINGS_CUSTOM_VIEW_ICONS } from '../../types';
 import { userViewSchema } from './user';
 describe('userViewSchema', () => {
     it('keys saved views by stable alias IDs', () => {
@@ -8,4 +9,10 @@ describe('userViewSchema', () => {
         expect(v.safeParse(userViewSchema, view).success).toBe(true);
         expect(v.safeParse(userViewSchema, legacyView).success).toBe(false);
     });
+    it('derives the ordered custom-view icon collection from enum-style values', () => {
+        expect(CustomViewIcon.STAR).toBe('STAR');
+        expect(USER_SETTINGS_CUSTOM_VIEW_ICONS).toEqual(['AIRPLANE', 'BELL', 'BRIEFCASE', 'CLOCK', 'CREDIT_CARD', 'HEART', 'HOME', 'KEY', 'MOON', 'PERSON', 'SHOPPING_CART', 'STAR']);
+        expect(USER_SETTINGS_CUSTOM_VIEW_ICONS).toEqual(Object.values(CustomViewIcon));
+        expect(Object.isFrozen(USER_SETTINGS_CUSTOM_VIEW_ICONS)).toBe(true);
+    });
 });

package/dist/schemas/oauth.d.ts

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

package/dist/schemas/oauth.js

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
 import { OAUTH_PROVIDERS } from '../types';
 export const oauth = {
-    provider: () => v.picklist(OAUTH_PROVIDERS),
+    provider: v.picklist(OAUTH_PROVIDERS),
 };

package/dist/schemas/pushNotifications.d.ts

@@ -1,11 +1,11 @@
 import * as v from 'valibot';
 export declare const pushNotifications: {
-    payload: v.UnionSchema<[v.ObjectSchema<{
+    payload: v.ObjectSchema<{
         readonly data: v.ObjectSchema<{
             readonly messageId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
             readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>;
         }, undefined>;
         readonly event: v.LiteralSchema<"EMAIL_RECEIVED", undefined>;
-    }, undefined>], undefined>;
+    }, undefined>;
 };
 //# sourceMappingURL=pushNotifications.d.ts.map

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

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

package/dist/schemas/pushNotifications.js

@@ -7,7 +7,6 @@ const pushNotificationEmailReceivedPayload = v.object({
     }),
     event: v.literal('EMAIL_RECEIVED'),
 });
-const pushNotificationPayload = v.union([pushNotificationEmailReceivedPayload]);
 export const pushNotifications = {
-    payload: pushNotificationPayload,
+    payload: pushNotificationEmailReceivedPayload,
 };

package/dist/schemas/schemaValues.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schemaValues.test.d.ts.map

package/dist/schemas/schemaValues.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaValues.test.d.ts","sourceRoot":"","sources":["../../src/schemas/schemaValues.test.ts"],"names":[],"mappings":""}

package/dist/schemas/schemaValues.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'bun:test';
+import * as v from 'valibot';
+import { marcoSchemas } from './index';
+describe('immutable schema values', () => {
+    it('publishes parameterless schemas as reusable values', () => {
+        expect(v.safeParse(marcoSchemas.app.platform, 'ios').success).toBe(true);
+        expect(v.safeParse(marcoSchemas.oauth.provider, 'GOOGLE').success).toBe(true);
+        expect(v.safeParse(marcoSchemas.emailAccount.imapConnectionStatus, 'CONNECTED').success).toBe(true);
+        expect(v.safeParse(marcoSchemas.emailAccount.socketTypeSchema, 'SSL').success).toBe(true);
+        expect(marcoSchemas.app.platform.type).toBe('picklist');
+        expect(marcoSchemas.oauth.provider.type).toBe('picklist');
+        expect(marcoSchemas.emailAccount.connectionConfigImapRaw.type).toBe('object');
+        expect(marcoSchemas.emailAccount.connectionConfigOauth.type).toBe('object');
+    });
+    it('parses the single supported push payload without a wrapper union', () => {
+        const payload = { data: { messageId: 'message-1', threadId: 'thread-1' }, event: 'EMAIL_RECEIVED' };
+        expect(v.safeParse(marcoSchemas.pushNotifications.payload, payload).success).toBe(true);
+        expect(v.safeParse(marcoSchemas.pushNotifications.payload, { ...payload, event: 'UNKNOWN' }).success).toBe(false);
+        expect(marcoSchemas.pushNotifications.payload.type).toBe('object');
+    });
+});

package/dist/types/UserSettings.d.ts

@@ -1,17 +1,18 @@
-export declare enum CustomViewIcon {
-    AIRPLANE = "AIRPLANE",
-    BELL = "BELL",
-    BRIEFCASE = "BRIEFCASE",
-    CLOCK = "CLOCK",
-    CREDIT_CARD = "CREDIT_CARD",
-    HEART = "HEART",
-    HOME = "HOME",
-    KEY = "KEY",
-    MOON = "MOON",
-    PERSON = "PERSON",
-    SHOPPING_CART = "SHOPPING_CART",
-    STAR = "STAR"
-}
-export declare const USER_SETTINGS_CUSTOM_VIEW_ICONS: readonly [CustomViewIcon.AIRPLANE, CustomViewIcon.BELL, CustomViewIcon.BRIEFCASE, CustomViewIcon.CLOCK, CustomViewIcon.CREDIT_CARD, CustomViewIcon.HEART, CustomViewIcon.HOME, CustomViewIcon.KEY, CustomViewIcon.MOON, CustomViewIcon.PERSON, CustomViewIcon.SHOPPING_CART, CustomViewIcon.STAR];
+export declare const CustomViewIcon: {
+    readonly AIRPLANE: "AIRPLANE";
+    readonly BELL: "BELL";
+    readonly BRIEFCASE: "BRIEFCASE";
+    readonly CLOCK: "CLOCK";
+    readonly CREDIT_CARD: "CREDIT_CARD";
+    readonly HEART: "HEART";
+    readonly HOME: "HOME";
+    readonly KEY: "KEY";
+    readonly MOON: "MOON";
+    readonly PERSON: "PERSON";
+    readonly SHOPPING_CART: "SHOPPING_CART";
+    readonly STAR: "STAR";
+};
+export type CustomViewIcon = (typeof CustomViewIcon)[keyof typeof CustomViewIcon];
+export declare const USER_SETTINGS_CUSTOM_VIEW_ICONS: readonly CustomViewIcon[];
 export type UserSettingsCustomViewIcon = (typeof USER_SETTINGS_CUSTOM_VIEW_ICONS)[number];
 //# sourceMappingURL=UserSettings.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"UserSettings.d.ts","sourceRoot":"","sources":["../../src/types/UserSettings.ts"],"names":[],"mappings":"AAAA,oBAAY,cAAc;IACxB,QAAQ,aAAa;IACrB,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,KAAK,UAAU;IACf,WAAW,gBAAgB;IAC3B,KAAK,UAAU;IACf,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,aAAa,kBAAkB;IAC/B,IAAI,SAAS;CACd;AAED,eAAO,MAAM,+BAA+B,mSAalC,CAAA;AAEV,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,+BAA+B,CAAC,CAAC,MAAM,CAAC,CAAA"}
+{"version":3,"file":"UserSettings.d.ts","sourceRoot":"","sources":["../../src/types/UserSettings.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAajB,CAAA;AAEV,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAA;AAEjF,eAAO,MAAM,+BAA+B,EAAE,SAAS,cAAc,EAAiD,CAAA;AAEtH,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,+BAA+B,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/UserSettings.js

@@ -1,29 +1,15 @@
-export var CustomViewIcon;
-(function (CustomViewIcon) {
-    CustomViewIcon["AIRPLANE"] = "AIRPLANE";
-    CustomViewIcon["BELL"] = "BELL";
-    CustomViewIcon["BRIEFCASE"] = "BRIEFCASE";
-    CustomViewIcon["CLOCK"] = "CLOCK";
-    CustomViewIcon["CREDIT_CARD"] = "CREDIT_CARD";
-    CustomViewIcon["HEART"] = "HEART";
-    CustomViewIcon["HOME"] = "HOME";
-    CustomViewIcon["KEY"] = "KEY";
-    CustomViewIcon["MOON"] = "MOON";
-    CustomViewIcon["PERSON"] = "PERSON";
-    CustomViewIcon["SHOPPING_CART"] = "SHOPPING_CART";
-    CustomViewIcon["STAR"] = "STAR";
-})(CustomViewIcon || (CustomViewIcon = {}));
-export const USER_SETTINGS_CUSTOM_VIEW_ICONS = [
-    CustomViewIcon.AIRPLANE,
-    CustomViewIcon.BELL,
-    CustomViewIcon.BRIEFCASE,
-    CustomViewIcon.CLOCK,
-    CustomViewIcon.CREDIT_CARD,
-    CustomViewIcon.HEART,
-    CustomViewIcon.HOME,
-    CustomViewIcon.KEY,
-    CustomViewIcon.MOON,
-    CustomViewIcon.PERSON,
-    CustomViewIcon.SHOPPING_CART,
-    CustomViewIcon.STAR,
-];
+export const CustomViewIcon = {
+    AIRPLANE: 'AIRPLANE',
+    BELL: 'BELL',
+    BRIEFCASE: 'BRIEFCASE',
+    CLOCK: 'CLOCK',
+    CREDIT_CARD: 'CREDIT_CARD',
+    HEART: 'HEART',
+    HOME: 'HOME',
+    KEY: 'KEY',
+    MOON: 'MOON',
+    PERSON: 'PERSON',
+    SHOPPING_CART: 'SHOPPING_CART',
+    STAR: 'STAR',
+};
+export const USER_SETTINGS_CUSTOM_VIEW_ICONS = Object.freeze(Object.values(CustomViewIcon));

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

@@ -1,4 +1,2 @@
-export declare const accountUtils: {
-    generateColor: (emailAddress: string) => string;
-};
+export { generateAccountColor } from './generateAccountColor';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/accounts/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;CAExB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/accounts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/utils/accounts/index.js

@@ -1,4 +1 @@
-import { generateAccountColor } from './generateAccountColor';
-export const accountUtils = {
-    generateColor: generateAccountColor,
-};
+export { generateAccountColor } from './generateAccountColor';

package/dist/utils/index.d.ts

@@ -1,4 +1,4 @@
-export { accountUtils } from './accounts';
-export { labelUtils } from './labels';
-export { threadsUtils } from './threads';
+export { generateAccountColor } from './accounts';
+export { labelSpecialUseOrdering } from './labels';
+export { parseLabelIdList, processSearchTerm } from './threads';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA"}

package/dist/utils/index.js

@@ -1,3 +1,3 @@
-export { accountUtils } from './accounts';
-export { labelUtils } from './labels';
-export { threadsUtils } from './threads';
+export { generateAccountColor } from './accounts';
+export { labelSpecialUseOrdering } from './labels';
+export { parseLabelIdList, processSearchTerm } from './threads';

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

@@ -1,4 +1,3 @@
-export declare const labelUtils: {
-    specialUseOrdering: ("ARCHIVE" | "INBOX" | "SENT" | "SPAM" | "TRASH")[];
-};
+import type { LabelSpecialUse } from '../../types';
+export declare const labelSpecialUseOrdering: readonly LabelSpecialUse[];
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/labels/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU;;CAEtB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/labels/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,eAAO,MAAM,uBAAuB,EAAE,SAAS,eAAe,EAAkD,CAAA"}

package/dist/utils/labels/index.js

@@ -1,4 +1 @@
-const labelSpecialUseOrdering = ['INBOX', 'SENT', 'SPAM', 'TRASH', 'ARCHIVE'];
-export const labelUtils = {
-    specialUseOrdering: labelSpecialUseOrdering,
-};
+export const labelSpecialUseOrdering = ['INBOX', 'SENT', 'SPAM', 'TRASH', 'ARCHIVE'];

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

@@ -1,5 +1,3 @@
-export declare const threadsUtils: {
-    parseLabelIdList: (labelIdList: string) => string[];
-    processSearchTerm: (term: string) => string[];
-};
+export { parseLabelIdList } from './parseLabelIdList/parseLabelIdList';
+export { processSearchTerm } from './processSearchTerm/processSearchTerm';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/threads/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;CAGxB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/threads/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAA;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAA"}

package/dist/utils/threads/index.js

@@ -1,6 +1,2 @@
-import { parseLabelIdList } from './parseLabelIdList';
-import { processSearchTerm } from './processSearchTerm';
-export const threadsUtils = {
-    parseLabelIdList,
-    processSearchTerm,
-};
+export { parseLabelIdList } from './parseLabelIdList/parseLabelIdList';
+export { processSearchTerm } from './processSearchTerm/processSearchTerm';

package/dist/utils/threads/parseLabelIdList/parseLabelIdList.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test';
-import { parseLabelIdList } from './index';
+import { parseLabelIdList } from './parseLabelIdList';
 describe('parseLabelIdList', () => {
     const testCases = [
         { description: 'parses space-separated IDs', expected: ['id1', 'id2', 'id3'], input: ' id1 id2 id3 ' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "4.0.15",
+  "version": "4.0.17",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",

package/dist/utils/threads/parseLabelIdList/index.d.ts

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

package/dist/utils/threads/parseLabelIdList/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/threads/parseLabelIdList/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/utils/threads/parseLabelIdList/index.js

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

package/dist/utils/threads/processSearchTerm/index.d.ts

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

package/dist/utils/threads/processSearchTerm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/threads/processSearchTerm/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/utils/threads/processSearchTerm/index.js

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