@marcoappio/marco-config 8.0.0 → 9.0.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { marcoConstants } from './constants';
 export { MARCO_ENV, type MarcoEnvironment, marcoPublicConfig } from './marcoPublicConfig';
-export { type Account, type AccountAlias, type AccountId, type AccountLabel, type AliasId, type AttachmentId, type Contact, type ContactId, type Draft, type DraftAttachment, type DraftBody, type DraftId, type LabelId, type MessageId, marcoSchemas, type PushNotificationTokenId, type RecipientId, type Thread, type ThreadId, type ThreadMessage, type ThreadMessageAttachment, type ThreadMessageRecipient, type User, type UserId, type UserPushNotificationToken, type UserView, type ViewId, } from './schemas';
+export { type Account, type AccountAlias, type AccountId, type AccountLabel, type AliasId, type AttachmentId, type Contact, type ContactId, type Draft, type DraftAttachment, type DraftBody, type DraftId, type LabelId, type LabelMove, type MessageId, marcoSchemas, type PushNotificationTokenId, type RecipientId, type Thread, type ThreadId, type ThreadMessage, type ThreadMessageAttachment, type ThreadMessageRecipient, type User, type UserId, type UserPushNotificationToken, type UserView, type ViewId, } from './schemas';
 export { marcoSDK } from './sdk';
 export * from './types';
 export { accountUtils, labelUtils, threadsUtils } from './utils';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACzF,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,YAAY,EACZ,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,IAAI,EACT,KAAK,MAAM,EACX,KAAK,yBAAyB,EAC9B,KAAK,QAAQ,EACb,KAAK,MAAM,GACZ,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACzF,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,SAAS,EACd,YAAY,EACZ,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,IAAI,EACT,KAAK,MAAM,EACX,KAAK,yBAAyB,EAC9B,KAAK,QAAQ,EACb,KAAK,MAAM,GACZ,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}

package/dist/schemas/index.d.ts

@@ -1,5 +1,5 @@
 export type { AccountId, AliasId, AttachmentId, ContactId, DraftId, LabelId, MessageId, PushNotificationTokenId, RecipientId, ThreadId, UserId, ViewId, } from './id';
-export type { Account, AccountAlias, AccountLabel, Contact, Draft, DraftAttachment, DraftBody, Thread, ThreadMessage, ThreadMessageAttachment, ThreadMessageRecipient, User, UserPushNotificationToken, UserView, } from './models';
+export type { Account, AccountAlias, AccountLabel, Contact, Draft, DraftAttachment, DraftBody, LabelMove, Thread, ThreadMessage, ThreadMessageAttachment, ThreadMessageRecipient, User, UserPushNotificationToken, UserView, } from './models';
 export { mutatorSchemas } from './mutators';
 export declare const marcoSchemas: {
     app: {
@@ -191,12 +191,42 @@ export declare const marcoSchemas: {
             readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
             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>;
         }, undefined>;
+        labelMoveSchema: import("valibot").VariantSchema<"status", [import("valibot").StrictObjectSchema<{
+            readonly canRetry: import("valibot").LiteralSchema<false, undefined>;
+            readonly failureCode: import("valibot").NullSchema<undefined>;
+            readonly status: import("valibot").LiteralSchema<"pending", undefined>;
+            readonly affectedThreadCount: import("valibot").SchemaWithPipe<readonly [import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>;
+            readonly mutationToken: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+            readonly target: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly canRetry: import("valibot").BooleanSchema<undefined>;
+            readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly status: import("valibot").LiteralSchema<"failed", undefined>;
+            readonly affectedThreadCount: import("valibot").SchemaWithPipe<readonly [import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>;
+            readonly mutationToken: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+            readonly target: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>], undefined>;
         threadListSchema: import("valibot").StrictObjectSchema<{
             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>;
+            labelMove: import("valibot").NullableSchema<import("valibot").VariantSchema<"status", [import("valibot").StrictObjectSchema<{
+                readonly canRetry: import("valibot").LiteralSchema<false, undefined>;
+                readonly failureCode: import("valibot").NullSchema<undefined>;
+                readonly status: import("valibot").LiteralSchema<"pending", undefined>;
+                readonly affectedThreadCount: import("valibot").SchemaWithPipe<readonly [import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>;
+                readonly mutationToken: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                readonly target: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly canRetry: import("valibot").BooleanSchema<undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly status: import("valibot").LiteralSchema<"failed", undefined>;
+                readonly affectedThreadCount: import("valibot").SchemaWithPipe<readonly [import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>;
+                readonly mutationToken: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                readonly target: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>], undefined>, undefined>;
             latestMessageDate: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, 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>;
@@ -240,6 +270,21 @@ export declare const marcoSchemas: {
             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>;
+            labelMove: import("valibot").NullableSchema<import("valibot").VariantSchema<"status", [import("valibot").StrictObjectSchema<{
+                readonly canRetry: import("valibot").LiteralSchema<false, undefined>;
+                readonly failureCode: import("valibot").NullSchema<undefined>;
+                readonly status: import("valibot").LiteralSchema<"pending", undefined>;
+                readonly affectedThreadCount: import("valibot").SchemaWithPipe<readonly [import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>;
+                readonly mutationToken: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                readonly target: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>, import("valibot").StrictObjectSchema<{
+                readonly canRetry: import("valibot").BooleanSchema<undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly status: import("valibot").LiteralSchema<"failed", undefined>;
+                readonly affectedThreadCount: import("valibot").SchemaWithPipe<readonly [import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>;
+                readonly mutationToken: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                readonly target: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>], undefined>, undefined>;
             latestMessageDate: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, 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>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AA8BA,YAAY,EACV,SAAS,EACT,OAAO,EACP,YAAY,EACZ,SAAS,EACT,OAAO,EACP,OAAO,EACP,SAAS,EACT,uBAAuB,EACvB,WAAW,EACX,QAAQ,EACR,MAAM,EACN,MAAM,GACP,MAAM,MAAM,CAAA;AACb,YAAY,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,KAAK,EACL,eAAe,EACf,SAAS,EACT,MAAM,EACN,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,IAAI,EACJ,yBAAyB,EACzB,QAAQ,GACT,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BxB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AA+BA,YAAY,EACV,SAAS,EACT,OAAO,EACP,YAAY,EACZ,SAAS,EACT,OAAO,EACP,OAAO,EACP,SAAS,EACT,uBAAuB,EACvB,WAAW,EACX,QAAQ,EACR,MAAM,EACN,MAAM,GACP,MAAM,MAAM,CAAA;AACb,YAAY,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,KAAK,EACL,eAAe,EACf,SAAS,EACT,SAAS,EACT,MAAM,EACN,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,IAAI,EACJ,yBAAyB,EACzB,QAAQ,GACT,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BxB,CAAA"}

package/dist/schemas/index.js

@@ -4,7 +4,7 @@ import { boolean } from './boolean';
 import { emailAccount } from './emailAccount';
 import { id } from './id';
 import { labels } from './labels';
-import { accountAliasSchema, accountLabelSchema, accountSchema, contactSchema, draftAttachmentSchema, draftBodySchema, draftSchema, threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, userPushNotificationTokenSchema, userSchema, userViewSchema, } from './models';
+import { accountAliasSchema, accountLabelSchema, accountSchema, contactSchema, draftAttachmentSchema, draftBodySchema, draftSchema, labelMoveSchema, threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, userPushNotificationTokenSchema, userSchema, userViewSchema, } from './models';
 import { mutatorSchemas } from './mutators';
 import { number } from './number';
 import { oauth } from './oauth';
@@ -27,6 +27,7 @@ export const marcoSchemas = {
         draftAttachmentSchema,
         draftBodySchema,
         draftSchema,
+        labelMoveSchema,
         threadListSchema,
         threadMessageAttachmentSchema,
         threadMessageRecipientSchema,

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, threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, } from './thread';
+export { type LabelMove, labelMoveSchema, type Thread, type ThreadMessage, type ThreadMessageAttachment, type ThreadMessageRecipient, threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, } from './thread';
 export { type User, type UserPushNotificationToken, type UserView, userPushNotificationTokenSchema, userSchema, 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,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,GACd,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,KAAK,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,EACL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,qBAAqB,EACrB,eAAe,EACf,WAAW,GACZ,MAAM,SAAS,CAAA;AAChB,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,EACL,KAAK,IAAI,EACT,KAAK,yBAAyB,EAC9B,KAAK,QAAQ,EACb,+BAA+B,EAC/B,UAAU,EACV,cAAc,GACf,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/models/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,GACd,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,KAAK,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,EACL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,qBAAqB,EACrB,eAAe,EACf,WAAW,GACZ,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,KAAK,SAAS,EACd,eAAe,EACf,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,EACL,KAAK,IAAI,EACT,KAAK,yBAAyB,EAC9B,KAAK,QAAQ,EACb,+BAA+B,EAC/B,UAAU,EACV,cAAc,GACf,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 { threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, } from './thread';
+export { labelMoveSchema, threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, } from './thread';
 export { userPushNotificationTokenSchema, userSchema, userViewSchema, } from './user';

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

@@ -24,12 +24,44 @@ export declare const threadMessageSchema: v.ObjectSchema<{
     readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>;
     readonly unsubscribeUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
 }, undefined>;
+export declare const labelMoveMutationTokenSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+export declare const labelMoveSchema: v.VariantSchema<"status", [v.StrictObjectSchema<{
+    readonly canRetry: v.LiteralSchema<false, undefined>;
+    readonly failureCode: v.NullSchema<undefined>;
+    readonly status: v.LiteralSchema<"pending", undefined>;
+    readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+    readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly canRetry: v.BooleanSchema<undefined>;
+    readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+    readonly status: v.LiteralSchema<"failed", undefined>;
+    readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+    readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+}, undefined>], undefined>;
+export type LabelMove = v.InferOutput<typeof labelMoveSchema>;
 export declare const threadSchema: v.StrictObjectSchema<{
     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>;
+    labelMove: v.NullableSchema<v.VariantSchema<"status", [v.StrictObjectSchema<{
+        readonly canRetry: v.LiteralSchema<false, undefined>;
+        readonly failureCode: v.NullSchema<undefined>;
+        readonly status: v.LiteralSchema<"pending", undefined>;
+        readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+        readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly canRetry: v.BooleanSchema<undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly status: v.LiteralSchema<"failed", undefined>;
+        readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+        readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>], undefined>, undefined>;
     latestMessageDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, 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>;
@@ -48,6 +80,21 @@ export declare const threadListSchema: v.StrictObjectSchema<{
     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>;
+    labelMove: v.NullableSchema<v.VariantSchema<"status", [v.StrictObjectSchema<{
+        readonly canRetry: v.LiteralSchema<false, undefined>;
+        readonly failureCode: v.NullSchema<undefined>;
+        readonly status: v.LiteralSchema<"pending", undefined>;
+        readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+        readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly canRetry: v.BooleanSchema<undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly status: v.LiteralSchema<"failed", undefined>;
+        readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+        readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>], undefined>, undefined>;
     latestMessageDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, 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>;

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;;;;;;;;;;aAU9B,CAAA;AAqBF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;aAAoC,CAAA;AAE7D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;aAAe,CAAA;AAE5C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,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;;;;;;;;;;aAU9B,CAAA;AAEF,eAAO,MAAM,4BAA4B,yFAA+B,CAAA;AAQxE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;0BAa1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,eAAe,CAAC,CAAA;AAsB7D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAAoC,CAAA;AAE7D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAAe,CAAA;AAE5C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,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"}

package/dist/schemas/models/thread.js

@@ -29,12 +29,33 @@ export const threadMessageSchema = v.object({
     threadId: id.threadId.required(),
     unsubscribeUrl: string.nullable(),
 });
+export const labelMoveMutationTokenSchema = v.pipe(v.string(), v.uuid());
+const labelMoveEntries = {
+    affectedThreadCount: v.pipe(number.positiveInteger(), v.minValue(1)),
+    mutationToken: labelMoveMutationTokenSchema,
+    target: string.required(),
+};
+export const labelMoveSchema = v.variant('status', [
+    v.strictObject({
+        ...labelMoveEntries,
+        canRetry: v.literal(false),
+        failureCode: v.null(),
+        status: v.literal('pending'),
+    }),
+    v.strictObject({
+        ...labelMoveEntries,
+        canRetry: v.boolean(),
+        failureCode: v.picklist(['MOVE_RECONCILIATION_FAILED', 'MOVE_RECOVERY_UNAVAILABLE']),
+        status: v.literal('failed'),
+    }),
+]);
 const threadBaseEntries = {
     accountId: id.accountId.required(),
     flagged: v.boolean(),
     hasAttachments: v.boolean(),
     id: id.threadId.required(),
     labelIdList: v.string(),
+    labelMove: v.nullable(labelMoveSchema),
     latestMessageDate: number.positiveInteger(),
     latestMessageId: id.messageId.required(),
     messageCount: number.positiveInteger(),

package/dist/sdk/endpoints/private/models/thread/getThread.d.ts

@@ -21,6 +21,21 @@ export declare const getThread: import("../../../../..").EndpointConfig<"/v1/pv/
         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>;
+        labelMove: v.NullableSchema<v.VariantSchema<"status", [v.StrictObjectSchema<{
+            readonly canRetry: v.LiteralSchema<false, undefined>;
+            readonly failureCode: v.NullSchema<undefined>;
+            readonly status: v.LiteralSchema<"pending", undefined>;
+            readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+            readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+            readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>, v.StrictObjectSchema<{
+            readonly canRetry: v.BooleanSchema<undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly status: v.LiteralSchema<"failed", undefined>;
+            readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+            readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+            readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>], undefined>, undefined>;
         latestMessageDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, 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>;

package/dist/sdk/endpoints/private/models/thread/getThread.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getThread.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAYpB,CAAA"}
+{"version":3,"file":"getThread.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAYpB,CAAA"}

package/dist/sdk/endpoints/private/models/thread/getThreadByMessageId.d.ts

@@ -21,6 +21,21 @@ export declare const getThreadByMessageId: import("../../../../..").EndpointConf
         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>;
+        labelMove: v.NullableSchema<v.VariantSchema<"status", [v.StrictObjectSchema<{
+            readonly canRetry: v.LiteralSchema<false, undefined>;
+            readonly failureCode: v.NullSchema<undefined>;
+            readonly status: v.LiteralSchema<"pending", undefined>;
+            readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+            readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+            readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>, v.StrictObjectSchema<{
+            readonly canRetry: v.BooleanSchema<undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly status: v.LiteralSchema<"failed", undefined>;
+            readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+            readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+            readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>], undefined>, undefined>;
         latestMessageDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, 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>;

package/dist/sdk/endpoints/private/models/thread/getThreadByMessageId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getThreadByMessageId.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThreadByMessageId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAY/B,CAAA"}
+{"version":3,"file":"getThreadByMessageId.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThreadByMessageId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAY/B,CAAA"}

package/dist/sdk/endpoints/private/models/thread/getThreadList.d.ts

@@ -60,6 +60,21 @@ export declare const getThreadList: import("../../../../..").EndpointConfig<"/v1
             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>;
+            labelMove: v.NullableSchema<v.VariantSchema<"status", [v.StrictObjectSchema<{
+                readonly canRetry: v.LiteralSchema<false, undefined>;
+                readonly failureCode: v.NullSchema<undefined>;
+                readonly status: v.LiteralSchema<"pending", undefined>;
+                readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+                readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>, v.StrictObjectSchema<{
+                readonly canRetry: v.BooleanSchema<undefined>;
+                readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly status: v.LiteralSchema<"failed", undefined>;
+                readonly affectedThreadCount: v.SchemaWithPipe<readonly [v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+                readonly target: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>], undefined>, undefined>;
             latestMessageDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, 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>;

package/dist/sdk/endpoints/private/models/thread/getThreadList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getThreadList.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThreadList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AA4C5B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAaxB,CAAA"}
+{"version":3,"file":"getThreadList.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThreadList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AA4C5B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAaxB,CAAA"}

package/dist/sdk/endpoints/private/mutations/thread/index.d.ts

@@ -1,6 +1,7 @@
 export { addLabel } from './addLabel';
 export { deleteThreads } from './deleteThreads';
 export { removeLabel } from './removeLabel';
+export { retryLabelMove } from './retryLabelMove';
 export { setArchive } from './setArchive';
 export { setFlagged } from './setFlagged';
 export { setInbox } from './setInbox';

package/dist/sdk/endpoints/private/mutations/thread/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/mutations/thread/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/mutations/thread/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/sdk/endpoints/private/mutations/thread/index.js

@@ -1,6 +1,7 @@
 export { addLabel } from './addLabel';
 export { deleteThreads } from './deleteThreads';
 export { removeLabel } from './removeLabel';
+export { retryLabelMove } from './retryLabelMove';
 export { setArchive } from './setArchive';
 export { setFlagged } from './setFlagged';
 export { setInbox } from './setInbox';

package/dist/sdk/endpoints/private/mutations/thread/retryLabelMove.d.ts

@@ -0,0 +1,37 @@
+import * as v from 'valibot';
+export declare const retryLabelMove: import("../../../../..").EndpointConfig<"/v1/pv/models/thread/:threadId/retry-label-move", v.StrictObjectSchema<{
+    readonly mutationToken: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+}, undefined>, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"THREAD_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MUTATION_REJECTED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=retryLabelMove.d.ts.map

package/dist/sdk/endpoints/private/mutations/thread/retryLabelMove.d.ts.map

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

package/dist/sdk/endpoints/private/mutations/thread/retryLabelMove.js

@@ -0,0 +1,17 @@
+import * as v from 'valibot';
+import { labelMoveMutationTokenSchema } from '../../../../../schemas/models/thread';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { errors } from '../../../../../sdk/validation/errors';
+export const retryLabelMove = createEndpoint({
+    body: v.strictObject({ mutationToken: labelMoveMutationTokenSchema }),
+    method: 'POST',
+    path: '/v1/pv/models/thread/:threadId/retry-label-move',
+    response: v.union([
+        errors.authFailedErrorSchema,
+        errors.userNotFoundErrorSchema,
+        errors.threadNotFoundErrorSchema,
+        errors.mutationRejectedErrorSchema,
+        errors.validationFailedErrorSchema,
+        v.object({ status: v.literal(200) }),
+    ]),
+});

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

@@ -1,2 +1,3 @@
+/** An empty result means there are no searchable words, not an unfiltered search. */
 export declare const processSearchTerm: (term: string) => string[];
 //# sourceMappingURL=processSearchTerm.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"processSearchTerm.d.ts","sourceRoot":"","sources":["../../../../src/utils/threads/processSearchTerm/processSearchTerm.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,iBAAiB,SAAU,MAAM,KAAG,MAAM,EAkBtD,CAAA"}
+{"version":3,"file":"processSearchTerm.d.ts","sourceRoot":"","sources":["../../../../src/utils/threads/processSearchTerm/processSearchTerm.ts"],"names":[],"mappings":"AAOA,qFAAqF;AACrF,eAAO,MAAM,iBAAiB,SAAU,MAAM,KAAG,MAAM,EAetD,CAAA"}

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

@@ -1,17 +1,18 @@
 import { stemmer } from '@orama/stemmers/english';
 import { stopwords } from '@orama/stopwords/english';
 const STOP_WORDS_SET = new Set(stopwords);
+const MIN_WORD_LENGTH = 3;
+const MAX_WORD_LENGTH = 30;
+/** An empty result means there are no searchable words, not an unfiltered search. */
 export const processSearchTerm = (term) => {
-    const sanitizedTerm = term.trim().toLowerCase();
-    const tokens = sanitizedTerm.split(/\s+/).filter(Boolean);
+    const tokens = term.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
     const wordSet = new Set();
     for (const token of tokens) {
-        if (STOP_WORDS_SET.has(token)) {
-            continue;
-        }
-        const stemmed = stemmer(token);
-        if (stemmed.length > 0) {
-            wordSet.add(stemmed);
+        if (token.length >= MIN_WORD_LENGTH && token.length < MAX_WORD_LENGTH && !STOP_WORDS_SET.has(token)) {
+            const stemmed = stemmer(token);
+            if (stemmed.length >= MIN_WORD_LENGTH && stemmed.length < MAX_WORD_LENGTH) {
+                wordSet.add(stemmed);
+            }
         }
     }
     return Array.from(wordSet);

package/package.json

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