npm - @marcoappio/marco-config - Versions diffs - 8.0.1 → 10.0.0 - Mend

@marcoappio/marco-config 8.0.1 → 10.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (36) hide show

package/dist/index.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

	@@ -1 +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"}
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,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 CHANGED Viewed

@@ -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,104 @@ 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 canSettle: import("valibot").LiteralSchema<false, undefined>;
+            readonly failureCode: import("valibot").NullSchema<undefined>;
+            readonly settledAt: 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 canSettle: import("valibot").BooleanSchema<undefined>;
+            readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: import("valibot").NullSchema<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>, import("valibot").StrictObjectSchema<{
+            readonly canRetry: import("valibot").LiteralSchema<false, undefined>;
+            readonly canSettle: import("valibot").LiteralSchema<false, undefined>;
+            readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: import("valibot").NullSchema<undefined>;
+            readonly status: import("valibot").LiteralSchema<"settling", 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").LiteralSchema<false, undefined>;
+            readonly canSettle: import("valibot").LiteralSchema<true, undefined>;
+            readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: import("valibot").NullSchema<undefined>;
+            readonly status: import("valibot").LiteralSchema<"settlement_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>, import("valibot").StrictObjectSchema<{
+            readonly canRetry: import("valibot").LiteralSchema<false, undefined>;
+            readonly canSettle: import("valibot").LiteralSchema<false, undefined>;
+            readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly status: import("valibot").LiteralSchema<"settled", 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 canSettle: import("valibot").LiteralSchema<false, undefined>;
+                readonly failureCode: import("valibot").NullSchema<undefined>;
+                readonly settledAt: 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 canSettle: import("valibot").BooleanSchema<undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: import("valibot").NullSchema<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>, import("valibot").StrictObjectSchema<{
+                readonly canRetry: import("valibot").LiteralSchema<false, undefined>;
+                readonly canSettle: import("valibot").LiteralSchema<false, undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: import("valibot").NullSchema<undefined>;
+                readonly status: import("valibot").LiteralSchema<"settling", 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").LiteralSchema<false, undefined>;
+                readonly canSettle: import("valibot").LiteralSchema<true, undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: import("valibot").NullSchema<undefined>;
+                readonly status: import("valibot").LiteralSchema<"settlement_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>, import("valibot").StrictObjectSchema<{
+                readonly canRetry: import("valibot").LiteralSchema<false, undefined>;
+                readonly canSettle: import("valibot").LiteralSchema<false, undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly status: import("valibot").LiteralSchema<"settled", 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 +332,52 @@ 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 canSettle: import("valibot").LiteralSchema<false, undefined>;
+                readonly failureCode: import("valibot").NullSchema<undefined>;
+                readonly settledAt: 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 canSettle: import("valibot").BooleanSchema<undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: import("valibot").NullSchema<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>, import("valibot").StrictObjectSchema<{
+                readonly canRetry: import("valibot").LiteralSchema<false, undefined>;
+                readonly canSettle: import("valibot").LiteralSchema<false, undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: import("valibot").NullSchema<undefined>;
+                readonly status: import("valibot").LiteralSchema<"settling", 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").LiteralSchema<false, undefined>;
+                readonly canSettle: import("valibot").LiteralSchema<true, undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: import("valibot").NullSchema<undefined>;
+                readonly status: import("valibot").LiteralSchema<"settlement_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>, import("valibot").StrictObjectSchema<{
+                readonly canRetry: import("valibot").LiteralSchema<false, undefined>;
+                readonly canSettle: import("valibot").LiteralSchema<false, undefined>;
+                readonly failureCode: import("valibot").PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly status: import("valibot").LiteralSchema<"settled", 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 CHANGED Viewed

	@@ -1 +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"}
1	+ {"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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

	@@ -1 +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"}
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,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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -24,12 +24,106 @@ 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 canSettle: v.LiteralSchema<false, undefined>;
+    readonly failureCode: v.NullSchema<undefined>;
+    readonly settledAt: 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 canSettle: v.BooleanSchema<undefined>;
+    readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+    readonly settledAt: v.NullSchema<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>, v.StrictObjectSchema<{
+    readonly canRetry: v.LiteralSchema<false, undefined>;
+    readonly canSettle: v.LiteralSchema<false, undefined>;
+    readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+    readonly settledAt: v.NullSchema<undefined>;
+    readonly status: v.LiteralSchema<"settling", 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.LiteralSchema<false, undefined>;
+    readonly canSettle: v.LiteralSchema<true, undefined>;
+    readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+    readonly settledAt: v.NullSchema<undefined>;
+    readonly status: v.LiteralSchema<"settlement_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>, v.StrictObjectSchema<{
+    readonly canRetry: v.LiteralSchema<false, undefined>;
+    readonly canSettle: v.LiteralSchema<false, undefined>;
+    readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+    readonly settledAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly status: v.LiteralSchema<"settled", 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 canSettle: v.LiteralSchema<false, undefined>;
+        readonly failureCode: v.NullSchema<undefined>;
+        readonly settledAt: 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 canSettle: v.BooleanSchema<undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly settledAt: v.NullSchema<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>, v.StrictObjectSchema<{
+        readonly canRetry: v.LiteralSchema<false, undefined>;
+        readonly canSettle: v.LiteralSchema<false, undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly settledAt: v.NullSchema<undefined>;
+        readonly status: v.LiteralSchema<"settling", 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.LiteralSchema<false, undefined>;
+        readonly canSettle: v.LiteralSchema<true, undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly settledAt: v.NullSchema<undefined>;
+        readonly status: v.LiteralSchema<"settlement_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>, v.StrictObjectSchema<{
+        readonly canRetry: v.LiteralSchema<false, undefined>;
+        readonly canSettle: v.LiteralSchema<false, undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly settledAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly status: v.LiteralSchema<"settled", 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 +142,52 @@ 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 canSettle: v.LiteralSchema<false, undefined>;
+        readonly failureCode: v.NullSchema<undefined>;
+        readonly settledAt: 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 canSettle: v.BooleanSchema<undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly settledAt: v.NullSchema<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>, v.StrictObjectSchema<{
+        readonly canRetry: v.LiteralSchema<false, undefined>;
+        readonly canSettle: v.LiteralSchema<false, undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly settledAt: v.NullSchema<undefined>;
+        readonly status: v.LiteralSchema<"settling", 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.LiteralSchema<false, undefined>;
+        readonly canSettle: v.LiteralSchema<true, undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly settledAt: v.NullSchema<undefined>;
+        readonly status: v.LiteralSchema<"settlement_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>, v.StrictObjectSchema<{
+        readonly canRetry: v.LiteralSchema<false, undefined>;
+        readonly canSettle: v.LiteralSchema<false, undefined>;
+        readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+        readonly settledAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly status: v.LiteralSchema<"settled", 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 CHANGED Viewed

	@@ -1 +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"}
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;AAEF,eAAO,MAAM,4BAA4B,yFAA+B,CAAA;AASxE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAyC1B,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 CHANGED Viewed

@@ -29,12 +29,62 @@ export const threadMessageSchema = v.object({
     threadId: id.threadId.required(),
     unsubscribeUrl: string.nullable(),
 });
+export const labelMoveMutationTokenSchema = v.pipe(v.string(), v.uuid());
+const labelMoveFailureCodeSchema = v.picklist(['MOVE_RECONCILIATION_FAILED', 'MOVE_RECOVERY_UNAVAILABLE']);
+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),
+        canSettle: v.literal(false),
+        failureCode: v.null(),
+        settledAt: v.null(),
+        status: v.literal('pending'),
+    }),
+    v.strictObject({
+        ...labelMoveEntries,
+        canRetry: v.boolean(),
+        canSettle: v.boolean(),
+        failureCode: labelMoveFailureCodeSchema,
+        settledAt: v.null(),
+        status: v.literal('failed'),
+    }),
+    v.strictObject({
+        ...labelMoveEntries,
+        canRetry: v.literal(false),
+        canSettle: v.literal(false),
+        failureCode: labelMoveFailureCodeSchema,
+        settledAt: v.null(),
+        status: v.literal('settling'),
+    }),
+    v.strictObject({
+        ...labelMoveEntries,
+        canRetry: v.literal(false),
+        canSettle: v.literal(true),
+        failureCode: labelMoveFailureCodeSchema,
+        settledAt: v.null(),
+        status: v.literal('settlement_failed'),
+    }),
+    v.strictObject({
+        ...labelMoveEntries,
+        canRetry: v.literal(false),
+        canSettle: v.literal(false),
+        failureCode: labelMoveFailureCodeSchema,
+        settledAt: number.positiveInteger(),
+        status: v.literal('settled'),
+    }),
+]);
 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 CHANGED Viewed

@@ -21,6 +21,52 @@ 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 canSettle: v.LiteralSchema<false, undefined>;
+            readonly failureCode: v.NullSchema<undefined>;
+            readonly settledAt: 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 canSettle: v.BooleanSchema<undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: v.NullSchema<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>, v.StrictObjectSchema<{
+            readonly canRetry: v.LiteralSchema<false, undefined>;
+            readonly canSettle: v.LiteralSchema<false, undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: v.NullSchema<undefined>;
+            readonly status: v.LiteralSchema<"settling", 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.LiteralSchema<false, undefined>;
+            readonly canSettle: v.LiteralSchema<true, undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: v.NullSchema<undefined>;
+            readonly status: v.LiteralSchema<"settlement_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>, v.StrictObjectSchema<{
+            readonly canRetry: v.LiteralSchema<false, undefined>;
+            readonly canSettle: v.LiteralSchema<false, undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly status: v.LiteralSchema<"settled", 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 CHANGED Viewed

	@@ -1 +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"}
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"}

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

@@ -21,6 +21,52 @@ 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 canSettle: v.LiteralSchema<false, undefined>;
+            readonly failureCode: v.NullSchema<undefined>;
+            readonly settledAt: 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 canSettle: v.BooleanSchema<undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: v.NullSchema<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>, v.StrictObjectSchema<{
+            readonly canRetry: v.LiteralSchema<false, undefined>;
+            readonly canSettle: v.LiteralSchema<false, undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: v.NullSchema<undefined>;
+            readonly status: v.LiteralSchema<"settling", 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.LiteralSchema<false, undefined>;
+            readonly canSettle: v.LiteralSchema<true, undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: v.NullSchema<undefined>;
+            readonly status: v.LiteralSchema<"settlement_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>, v.StrictObjectSchema<{
+            readonly canRetry: v.LiteralSchema<false, undefined>;
+            readonly canSettle: v.LiteralSchema<false, undefined>;
+            readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+            readonly settledAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly status: v.LiteralSchema<"settled", 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 CHANGED Viewed

	@@ -1 +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"}
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"}

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

@@ -60,6 +60,52 @@ 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 canSettle: v.LiteralSchema<false, undefined>;
+                readonly failureCode: v.NullSchema<undefined>;
+                readonly settledAt: 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 canSettle: v.BooleanSchema<undefined>;
+                readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: v.NullSchema<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>, v.StrictObjectSchema<{
+                readonly canRetry: v.LiteralSchema<false, undefined>;
+                readonly canSettle: v.LiteralSchema<false, undefined>;
+                readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: v.NullSchema<undefined>;
+                readonly status: v.LiteralSchema<"settling", 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.LiteralSchema<false, undefined>;
+                readonly canSettle: v.LiteralSchema<true, undefined>;
+                readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: v.NullSchema<undefined>;
+                readonly status: v.LiteralSchema<"settlement_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>, v.StrictObjectSchema<{
+                readonly canRetry: v.LiteralSchema<false, undefined>;
+                readonly canSettle: v.LiteralSchema<false, undefined>;
+                readonly failureCode: v.PicklistSchema<["MOVE_RECONCILIATION_FAILED", "MOVE_RECOVERY_UNAVAILABLE"], undefined>;
+                readonly settledAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly status: v.LiteralSchema<"settled", 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 CHANGED Viewed

	@@ -1 +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"}
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"}

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

@@ -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';
@@ -8,4 +9,5 @@ export { setSeen } from './setSeen';
 export { setSnooze } from './setSnooze';
 export { setSpam } from './setSpam';
 export { setTrash } from './setTrash';
+export { settleLabelMove } from './settleLabelMove';
 //# sourceMappingURL=index.d.ts.map

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

	@@ -1 +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"}
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,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;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA"}

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

@@ -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';
@@ -8,3 +9,4 @@ export { setSeen } from './setSeen';
 export { setSnooze } from './setSnooze';
 export { setSpam } from './setSpam';
 export { setTrash } from './setTrash';
+export { settleLabelMove } from './settleLabelMove';

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

@@ -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 ADDED Viewed

	@@ -0,0 +1 @@
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 ADDED Viewed

@@ -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/sdk/endpoints/private/mutations/thread/settleLabelMove.d.ts ADDED Viewed

@@ -0,0 +1,44 @@
+import * as v from 'valibot';
+export declare const settleLabelMove: import("../../../../..").EndpointConfig<"/v1/pv/models/thread/:threadId/settle-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<"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 data: v.ObjectSchema<{
+        readonly code: v.PicklistSchema<["MOVE_INTENT_STALE", "MOVE_STILL_ACTIVE"], undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MOVE_EVIDENCE_UNAVAILABLE", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<503, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<202, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=settleLabelMove.d.ts.map

package/dist/sdk/endpoints/private/mutations/thread/settleLabelMove.d.ts.map ADDED Viewed

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

package/dist/sdk/endpoints/private/mutations/thread/settleLabelMove.js ADDED Viewed

@@ -0,0 +1,19 @@
+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 settleLabelMove = createEndpoint({
+    body: v.strictObject({ mutationToken: labelMoveMutationTokenSchema }),
+    method: 'POST',
+    path: '/v1/pv/models/thread/:threadId/settle-label-move',
+    response: v.union([
+        errors.authFailedErrorSchema,
+        errors.userNotFoundErrorSchema,
+        errors.threadNotFoundErrorSchema,
+        errors.validationFailedErrorSchema,
+        errors.labelMoveConflictErrorSchema,
+        errors.labelMoveEvidenceUnavailableErrorSchema,
+        v.object({ status: v.literal(200) }),
+        v.object({ status: v.literal(202) }),
+    ]),
+});

package/dist/sdk/index.d.ts CHANGED Viewed

@@ -505,6 +505,18 @@ export declare const marcoSDK: {
                 }, undefined>;
                 readonly status: import("valibot").LiteralSchema<409, undefined>;
             }, undefined>;
+            readonly labelMoveConflictErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").PicklistSchema<["MOVE_INTENT_STALE", "MOVE_STILL_ACTIVE"], undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<409, undefined>;
+            }, undefined>;
+            readonly labelMoveEvidenceUnavailableErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"MOVE_EVIDENCE_UNAVAILABLE", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<503, undefined>;
+            }, undefined>;
             readonly labelNotFoundErrorSchema: import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"LABEL_NOT_FOUND", undefined>;

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

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

package/dist/sdk/validation/errors.d.ts CHANGED Viewed

@@ -101,6 +101,18 @@ export declare const mutationRejectedErrorSchema: v.ObjectSchema<{
     }, undefined>;
     readonly status: v.LiteralSchema<409, undefined>;
 }, undefined>;
+export declare const labelMoveConflictErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.PicklistSchema<["MOVE_INTENT_STALE", "MOVE_STILL_ACTIVE"], undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>;
+export declare const labelMoveEvidenceUnavailableErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MOVE_EVIDENCE_UNAVAILABLE", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<503, undefined>;
+}, undefined>;
 export declare const threadNotFoundErrorSchema: v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly code: v.LiteralSchema<"THREAD_NOT_FOUND", undefined>;
@@ -293,6 +305,18 @@ export declare const errors: {
         }, undefined>;
         readonly status: v.LiteralSchema<409, undefined>;
     }, undefined>;
+    readonly labelMoveConflictErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.PicklistSchema<["MOVE_INTENT_STALE", "MOVE_STILL_ACTIVE"], undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<409, undefined>;
+    }, undefined>;
+    readonly labelMoveEvidenceUnavailableErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"MOVE_EVIDENCE_UNAVAILABLE", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<503, undefined>;
+    }, undefined>;
     readonly labelNotFoundErrorSchema: v.ObjectSchema<{
         readonly data: v.ObjectSchema<{
             readonly code: v.LiteralSchema<"LABEL_NOT_FOUND", undefined>;

package/dist/sdk/validation/errors.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;aAGzC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;aAGlD,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;aAGhC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;aAG3C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;aAGtC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;aAUtC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,MAAM~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BT~~,CAAA"}
1	+ {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;aAGzC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;aAGlD,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;aAGhC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;aAG3C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;aAGtC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;aAGvC,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;aAGlD,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;aAUtC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BT,CAAA"}

package/dist/sdk/validation/errors.js CHANGED Viewed

@@ -67,6 +67,14 @@ export const mutationRejectedErrorSchema = v.object({
     data: v.object({ code: v.literal('MUTATION_REJECTED') }),
     status: v.literal(409),
 });
+export const labelMoveConflictErrorSchema = v.object({
+    data: v.object({ code: v.picklist(['MOVE_INTENT_STALE', 'MOVE_STILL_ACTIVE']) }),
+    status: v.literal(409),
+});
+export const labelMoveEvidenceUnavailableErrorSchema = v.object({
+    data: v.object({ code: v.literal('MOVE_EVIDENCE_UNAVAILABLE') }),
+    status: v.literal(503),
+});
 export const threadNotFoundErrorSchema = v.object({
     data: v.object({ code: v.literal('THREAD_NOT_FOUND') }),
     status: v.literal(404),
@@ -139,6 +147,8 @@ export const errors = {
     invalidImageDimensionsErrorSchema,
     inviteNotFoundErrorSchema,
     labelAlreadyExistsErrorSchema,
+    labelMoveConflictErrorSchema,
+    labelMoveEvidenceUnavailableErrorSchema,
     labelNotFoundErrorSchema,
     messageNotFoundErrorSchema,
     mutationRejectedErrorSchema,

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

@@ -120,6 +120,18 @@ export declare const validation: {
             }, undefined>;
             readonly status: import("valibot").LiteralSchema<409, undefined>;
         }, undefined>;
+        readonly labelMoveConflictErrorSchema: import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").PicklistSchema<["MOVE_INTENT_STALE", "MOVE_STILL_ACTIVE"], undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<409, undefined>;
+        }, undefined>;
+        readonly labelMoveEvidenceUnavailableErrorSchema: import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"MOVE_EVIDENCE_UNAVAILABLE", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<503, undefined>;
+        }, undefined>;
         readonly labelNotFoundErrorSchema: import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly code: import("valibot").LiteralSchema<"LABEL_NOT_FOUND", undefined>;

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

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

package/dist/types/SDKError.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
 import type * as v from 'valibot';
 import type { errors } from '../sdk/validation/errors';
-export type SDKError = v.InferOutput<typeof errors.accountNotFoundErrorSchema> | v.InferOutput<typeof errors.aliasNotFoundErrorSchema> | v.InferOutput<typeof errors.attachmentNotFoundErrorSchema> | v.InferOutput<typeof errors.attachmentSizeMismatchErrorSchema> | v.InferOutput<typeof errors.attachmentStateInvalidErrorSchema> | v.InferOutput<typeof errors.attachmentUploadFailedErrorSchema> | v.InferOutput<typeof errors.authCodeExpiredErrorSchema> | v.InferOutput<typeof errors.authCodeInvalidErrorSchema> | v.InferOutput<typeof errors.authCodePreviouslyUsedErrorSchema> | v.InferOutput<typeof errors.authFailedErrorSchema> | v.InferOutput<typeof errors.authRefreshTokenInvalid> | v.InferOutput<typeof errors.authServerResponseUnexpectedErrorSchema> | v.InferOutput<typeof errors.authTooManyAttemptsErrorSchema> | v.InferOutput<typeof errors.contactNotFoundErrorSchema> | v.InferOutput<typeof errors.draftNotFoundErrorSchema> | v.InferOutput<typeof errors.fileTooLargeErrorSchema> | v.InferOutput<typeof errors.invalidFileTypeErrorSchema> | v.InferOutput<typeof errors.invalidImageDimensionsErrorSchema> | v.InferOutput<typeof errors.inviteNotFoundErrorSchema> | v.InferOutput<typeof errors.labelAlreadyExistsErrorSchema> | v.InferOutput<typeof errors.labelNotFoundErrorSchema> | v.InferOutput<typeof errors.messageNotFoundErrorSchema> | v.InferOutput<typeof errors.mutationRejectedErrorSchema> | v.InferOutput<typeof errors.threadNotFoundErrorSchema> | v.InferOutput<typeof errors.userMarkedForDeletionErrorSchema> | v.InferOutput<typeof errors.userNotFoundErrorSchema> | v.InferOutput<typeof errors.validationFailedErrorSchema> | v.InferOutput<typeof errors.viewNotFoundErrorSchema>;
+export type SDKError = v.InferOutput<typeof errors.accountNotFoundErrorSchema> | v.InferOutput<typeof errors.aliasNotFoundErrorSchema> | v.InferOutput<typeof errors.attachmentNotFoundErrorSchema> | v.InferOutput<typeof errors.attachmentSizeMismatchErrorSchema> | v.InferOutput<typeof errors.attachmentStateInvalidErrorSchema> | v.InferOutput<typeof errors.attachmentUploadFailedErrorSchema> | v.InferOutput<typeof errors.authCodeExpiredErrorSchema> | v.InferOutput<typeof errors.authCodeInvalidErrorSchema> | v.InferOutput<typeof errors.authCodePreviouslyUsedErrorSchema> | v.InferOutput<typeof errors.authFailedErrorSchema> | v.InferOutput<typeof errors.authRefreshTokenInvalid> | v.InferOutput<typeof errors.authServerResponseUnexpectedErrorSchema> | v.InferOutput<typeof errors.authTooManyAttemptsErrorSchema> | v.InferOutput<typeof errors.contactNotFoundErrorSchema> | v.InferOutput<typeof errors.draftNotFoundErrorSchema> | v.InferOutput<typeof errors.fileTooLargeErrorSchema> | v.InferOutput<typeof errors.invalidFileTypeErrorSchema> | v.InferOutput<typeof errors.invalidImageDimensionsErrorSchema> | v.InferOutput<typeof errors.inviteNotFoundErrorSchema> | v.InferOutput<typeof errors.labelAlreadyExistsErrorSchema> | v.InferOutput<typeof errors.labelMoveConflictErrorSchema> | v.InferOutput<typeof errors.labelMoveEvidenceUnavailableErrorSchema> | v.InferOutput<typeof errors.labelNotFoundErrorSchema> | v.InferOutput<typeof errors.messageNotFoundErrorSchema> | v.InferOutput<typeof errors.mutationRejectedErrorSchema> | v.InferOutput<typeof errors.threadNotFoundErrorSchema> | v.InferOutput<typeof errors.userMarkedForDeletionErrorSchema> | v.InferOutput<typeof errors.userNotFoundErrorSchema> | v.InferOutput<typeof errors.validationFailedErrorSchema> | v.InferOutput<typeof errors.viewNotFoundErrorSchema>;
 //# sourceMappingURL=SDKError.d.ts.map

package/dist/types/SDKError.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"SDKError.d.ts","sourceRoot":"","sources":["../../src/types/SDKError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAA;AAEjE,MAAM,MAAM,QAAQ,GAChB,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,6BAA6B,CAAC,GAC1D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,qBAAqB,CAAC,GAClD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uCAAuC,CAAC,GACpE,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,8BAA8B,CAAC,GAC3D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,yBAAyB,CAAC,GACtD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,6BAA6B,CAAC,GAC1D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GACxD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,yBAAyB,CAAC,GACtD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,gCAAgC,CAAC,GAC7D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GACxD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,CAAA"}
1	+ {"version":3,"file":"SDKError.d.ts","sourceRoot":"","sources":["../../src/types/SDKError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAA;AAEjE,MAAM,MAAM,QAAQ,GAChB,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,6BAA6B,CAAC,GAC1D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,qBAAqB,CAAC,GAClD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uCAAuC,CAAC,GACpE,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,8BAA8B,CAAC,GAC3D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,yBAAyB,CAAC,GACtD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,6BAA6B,CAAC,GAC1D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,4BAA4B,CAAC,GACzD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uCAAuC,CAAC,GACpE,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GACxD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,yBAAyB,CAAC,GACtD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,gCAAgC,CAAC,GAC7D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GACxD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,CAAA"}

package/package.json CHANGED Viewed

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