@marcoappio/marco-config 9.0.0 → 10.0.1

package/dist/schemas/index.d.ts

@@ -193,18 +193,49 @@ export declare const marcoSchemas: {
         }, 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>;
@@ -214,28 +245,59 @@ export declare const marcoSchemas: {
             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>;
-            previewText: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            previewText: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>;
             seen: import("valibot").BooleanSchema<undefined>;
             senderEmail: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            senderName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            senderName: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"", undefined>, import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             snoozedUntil: import("valibot").NullableSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-            subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            subject: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"", undefined>, import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             userId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "UserId">]>, undefined>;
             words: import("valibot").StringSchema<undefined>;
         }, undefined>;
@@ -256,11 +318,11 @@ export declare const marcoSchemas: {
         threadMessageSchema: import("valibot").ObjectSchema<{
             readonly 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>;
             readonly envelopeDate: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-            readonly envelopeSubject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly envelopeSubject: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"", undefined>, import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "MessageId">]>, undefined>;
-            readonly previewText: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly previewText: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>;
             readonly senderEmail: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly senderName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly senderName: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"", undefined>, import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             readonly threadId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>;
             readonly unsubscribeUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
@@ -272,28 +334,59 @@ export declare const marcoSchemas: {
             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>;
-            previewText: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            previewText: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>;
             seen: import("valibot").BooleanSchema<undefined>;
             senderEmail: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            senderName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            senderName: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"", undefined>, import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             snoozedUntil: import("valibot").NullableSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-            subject: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            subject: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"", undefined>, import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             userId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "UserId">]>, undefined>;
             words: import("valibot").StringSchema<undefined>;
         }, undefined>;

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

@@ -1 +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"}
+{"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/models/thread.d.ts

@@ -16,29 +16,60 @@ export declare const threadMessageRecipientSchema: v.ObjectSchema<{
 export declare const threadMessageSchema: v.ObjectSchema<{
     readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
     readonly envelopeDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-    readonly envelopeSubject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly envelopeSubject: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
     readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
-    readonly previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly previewText: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>;
     readonly senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    readonly senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly senderName: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
     readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>;
     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<{
@@ -49,28 +80,59 @@ export declare const threadSchema: v.StrictObjectSchema<{
     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>;
-    previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    previewText: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>;
     seen: v.BooleanSchema<undefined>;
     senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    senderName: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
     snoozedUntil: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-    subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    subject: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
     userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
     words: v.StringSchema<undefined>;
 }, undefined>;
@@ -82,28 +144,59 @@ export declare const threadListSchema: v.StrictObjectSchema<{
     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>;
-    previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    previewText: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>;
     seen: v.BooleanSchema<undefined>;
     senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    senderName: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
     snoozedUntil: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-    subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    subject: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
     userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
     words: v.StringSchema<undefined>;
 }, undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../../src/schemas/models/thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAQ5B,eAAO,MAAM,6BAA6B;;;;;;aAMxC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;aAMvC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;aAU9B,CAAA;AAEF,eAAO,MAAM,4BAA4B,yFAA+B,CAAA;AAQxE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;0BAa1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,eAAe,CAAC,CAAA;AAsB7D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAAoC,CAAA;AAE7D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAAe,CAAA;AAE5C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACnE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAA;AACzF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAA"}
+{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../../src/schemas/models/thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAW5B,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

@@ -4,6 +4,8 @@ import { id } from '../../schemas/id';
 import { number } from '../../schemas/number';
 import { string } from '../../schemas/string';
 import { MESSAGE_RECIPIENT_TYPES } from '../../types';
+const previewTextSchema = v.pipe(v.string(), v.maxLength(messages.PREVIEW_TEXT_MAX_LENGTH));
+const nullableDisplayTextSchema = v.union([v.literal(''), string.nullable()]);
 export const threadMessageAttachmentSchema = v.object({
     fileName: string.required(),
     id: id.attachmentId.required(),
@@ -21,15 +23,16 @@ export const threadMessageRecipientSchema = v.object({
 export const threadMessageSchema = v.object({
     accountId: id.accountId.required(),
     envelopeDate: number.positiveInteger(),
-    envelopeSubject: string.nullable(),
+    envelopeSubject: nullableDisplayTextSchema,
     id: id.messageId.required(),
-    previewText: string.required(messages.PREVIEW_TEXT_MAX_LENGTH),
+    previewText: previewTextSchema,
     senderEmail: string.required(),
-    senderName: string.nullable(),
+    senderName: nullableDisplayTextSchema,
     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,
@@ -39,15 +42,43 @@ 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(),
-        failureCode: v.picklist(['MOVE_RECONCILIATION_FAILED', 'MOVE_RECOVERY_UNAVAILABLE']),
+        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(),
@@ -59,12 +90,12 @@ const threadBaseEntries = {
     latestMessageDate: number.positiveInteger(),
     latestMessageId: id.messageId.required(),
     messageCount: number.positiveInteger(),
-    previewText: string.required(messages.PREVIEW_TEXT_MAX_LENGTH),
+    previewText: previewTextSchema,
     seen: v.boolean(),
     senderEmail: string.required(),
-    senderName: string.nullable(),
+    senderName: nullableDisplayTextSchema,
     snoozedUntil: v.nullable(number.positiveInteger()),
-    subject: string.nullable(),
+    subject: nullableDisplayTextSchema,
     userId: id.userId.required(),
     words: v.string(),
 };

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

@@ -23,28 +23,59 @@ export declare const getThread: import("../../../../..").EndpointConfig<"/v1/pv/
         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>;
-        previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        previewText: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>;
         seen: v.BooleanSchema<undefined>;
         senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        senderName: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
         snoozedUntil: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-        subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        subject: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
         userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
         words: v.StringSchema<undefined>;
     }, undefined>;

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

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

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

@@ -23,28 +23,59 @@ export declare const getThreadByMessageId: import("../../../../..").EndpointConf
         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>;
-        previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        previewText: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>;
         seen: v.BooleanSchema<undefined>;
         senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        senderName: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
         snoozedUntil: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-        subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        subject: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
         userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
         words: v.StringSchema<undefined>;
     }, undefined>;

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

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

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

@@ -62,28 +62,59 @@ export declare const getThreadList: import("../../../../..").EndpointConfig<"/v1
             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>;
-            previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            previewText: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>;
             seen: v.BooleanSchema<undefined>;
             senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            senderName: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             snoozedUntil: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-            subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            subject: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
             words: v.StringSchema<undefined>;
         }, undefined>, undefined>;

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

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

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

@@ -32,11 +32,11 @@ export declare const getThreadMessages: import("../../../../..").EndpointConfig<
         readonly items: v.ArraySchema<v.ObjectSchema<{
             readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
             readonly envelopeDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            readonly envelopeSubject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly envelopeSubject: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
-            readonly previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly previewText: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>]>;
             readonly senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly senderName: v.UnionSchema<[v.LiteralSchema<"", undefined>, v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>], undefined>;
             readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>;
             readonly unsubscribeUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>, undefined>;

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

@@ -9,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

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

@@ -9,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/settleLabelMove.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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