@marcoappio/marco-config 2.0.575 → 2.0.577

package/dist/appwrite/commands.d.ts

@@ -0,0 +1,345 @@
+import * as v from 'valibot';
+export declare const appwriteCommands: {
+    readonly errorCodes: readonly ["AUTHENTICATION_FAILED", "AUTHORIZATION_FAILED", "COMMAND_CONFLICT", "COMMAND_NOT_FOUND", "INVALID_COMMAND", "PROVIDER_REJECTED", "TRANSIENT_FAILURE", "INTERNAL_ERROR"];
+    readonly errorSchema: v.StrictObjectSchema<{
+        readonly code: v.PicklistSchema<readonly ["AUTHENTICATION_FAILED", "AUTHORIZATION_FAILED", "COMMAND_CONFLICT", "COMMAND_NOT_FOUND", "INVALID_COMMAND", "PROVIDER_REJECTED", "TRANSIENT_FAILURE", "INTERNAL_ERROR"], undefined>;
+        readonly retryable: v.BooleanSchema<undefined>;
+    }, undefined>;
+    readonly kinds: readonly ["profile.settings.set", "account.settings.set", "account.delete", "alias.create", "alias.delete", "alias.name.set", "alias.primary.set", "alias.signature.set", "label.create", "label.delete", "label.rename", "thread.label.add", "thread.label.remove", "thread.archive.set", "thread.flagged.set", "thread.seen.set", "thread.snooze.set", "thread.spam.set", "thread.trash.set", "thread.delete", "draft.create", "draft.content.set", "draft.envelope.set", "draft.from.set", "draft.delete", "draft.attachment.link", "draft.attachment.delete", "draft.send", "draft.send.cancel", "draft.send.schedule"];
+    readonly requestSchema: v.VariantSchema<"kind", readonly [v.StrictObjectSchema<{
+        readonly accountId: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, undefined>;
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"profile.settings.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly name: v.OptionalSchema<v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>, undefined>;
+            readonly timezone: v.OptionalSchema<v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"account.settings.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly colour: v.OptionalSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+            readonly displayName: v.OptionalSchema<v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"account.delete", undefined>;
+        readonly payload: v.StrictObjectSchema<{}, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"alias.create", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>;
+            readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
+            readonly name: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+            readonly signature: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 50000, undefined>]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"alias.delete", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"alias.name.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>;
+            readonly name: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"alias.primary.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"alias.signature.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>;
+            readonly signature: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 50000, undefined>]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"label.create", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly labelId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "LabelId">]>, undefined>;
+            readonly path: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"label.delete", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly labelId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "LabelId">]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"label.rename", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly labelId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "LabelId">]>, undefined>;
+            readonly path: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"thread.label.add", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly labelId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "LabelId">]>, undefined>;
+            readonly threadIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>, v.MinLengthAction<(string & v.Brand<"ThreadId">)[], 1, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"thread.label.remove", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly labelId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "LabelId">]>, undefined>;
+            readonly threadIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>, v.MinLengthAction<(string & v.Brand<"ThreadId">)[], 1, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"thread.archive.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly archived: v.BooleanSchema<undefined>;
+            readonly threadIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>, v.MinLengthAction<(string & v.Brand<"ThreadId">)[], 1, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"thread.flagged.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly flagged: v.BooleanSchema<undefined>;
+            readonly threadIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>, v.MinLengthAction<(string & v.Brand<"ThreadId">)[], 1, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"thread.seen.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly seen: v.BooleanSchema<undefined>;
+            readonly threadIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>, v.MinLengthAction<(string & v.Brand<"ThreadId">)[], 1, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"thread.snooze.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly snoozedUntil: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+            readonly threadIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>, v.MinLengthAction<(string & v.Brand<"ThreadId">)[], 1, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"thread.spam.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly spam: v.BooleanSchema<undefined>;
+            readonly threadIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>, v.MinLengthAction<(string & v.Brand<"ThreadId">)[], 1, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"thread.trash.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly threadIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>, v.MinLengthAction<(string & v.Brand<"ThreadId">)[], 1, undefined>]>;
+            readonly trashed: v.BooleanSchema<undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"thread.delete", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly threadIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>, v.MinLengthAction<(string & v.Brand<"ThreadId">)[], 1, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.create", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+            readonly fromAliasId: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>, undefined>;
+            readonly referencedMessageId: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>, undefined>;
+            readonly type: v.PicklistSchema<readonly ["NEW", "REPLY", "FORWARD"], undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.content.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+            readonly html: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 384000, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.envelope.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>, undefined>;
+            readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>, undefined>;
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+            readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 998, undefined>]>, undefined>;
+            readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.from.set", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+            readonly fromAliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.delete", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.attachment.link", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+            readonly fileId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly fileName: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.attachment.delete", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+            readonly fileId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.send", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.send.cancel", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        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 id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly kind: v.LiteralSchema<"draft.send.schedule", undefined>;
+        readonly payload: v.StrictObjectSchema<{
+            readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
+            readonly scheduledAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        }, undefined>;
+        readonly submittedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        readonly version: v.LiteralSchema<1, undefined>;
+    }, undefined>], undefined>;
+    readonly responseSchema: v.VariantSchema<"state", readonly [v.StrictObjectSchema<{
+        readonly canonicalRevision: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly error: v.NullSchema<undefined>;
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly state: v.LiteralSchema<"ACCEPTED", undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly canonicalRevision: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly error: v.NullSchema<undefined>;
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly state: v.LiteralSchema<"RUNNING", undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly canonicalRevision: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly error: v.NullSchema<undefined>;
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly state: v.LiteralSchema<"SUCCEEDED", undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly canonicalRevision: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly error: v.StrictObjectSchema<{
+            readonly code: v.PicklistSchema<readonly ["AUTHENTICATION_FAILED", "AUTHORIZATION_FAILED", "COMMAND_CONFLICT", "COMMAND_NOT_FOUND", "INVALID_COMMAND", "PROVIDER_REJECTED", "TRANSIENT_FAILURE", "INTERNAL_ERROR"], undefined>;
+            readonly retryable: v.BooleanSchema<undefined>;
+        }, undefined>;
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>, v.BrandAction<string, "CommandId">]>;
+        readonly state: v.LiteralSchema<"FAILED", undefined>;
+    }, undefined>], undefined>;
+    readonly states: readonly ["ACCEPTED", "RUNNING", "SUCCEEDED", "FAILED"];
+    readonly version: 1;
+};
+export type AppwriteCommandError = v.InferOutput<typeof appwriteCommands.errorSchema>;
+export type AppwriteCommandRequest = v.InferOutput<typeof appwriteCommands.requestSchema>;
+export type AppwriteCommandKind = AppwriteCommandRequest['kind'];
+export type AppwriteCommandPayload<TKind extends AppwriteCommandKind> = Extract<AppwriteCommandRequest, {
+    kind: TKind;
+}>['payload'];
+export type AppwriteCommandResponse = v.InferOutput<typeof appwriteCommands.responseSchema>;
+export type AppwriteCommandState = AppwriteCommandResponse['state'];
+//# sourceMappingURL=commands.d.ts.map

package/dist/appwrite/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/appwrite/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAiQ5B,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQnB,CAAA;AAEV,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,WAAW,CAAC,CAAA;AACrF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,aAAa,CAAC,CAAA;AACzF,MAAM,MAAM,mBAAmB,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAA;AAChE,MAAM,MAAM,sBAAsB,CAAC,KAAK,SAAS,mBAAmB,IAAI,OAAO,CAC7E,sBAAsB,EACtB;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAChB,CAAC,SAAS,CAAC,CAAA;AACZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,cAAc,CAAC,CAAA;AAC3F,MAAM,MAAM,oBAAoB,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAA"}

package/dist/appwrite/commands.js

@@ -0,0 +1,237 @@
+import * as v from 'valibot';
+import { id } from '../schemas/id';
+import { string } from '../schemas/string';
+import { DRAFT_TYPES } from '../types';
+const commandIdSchema = v.pipe(v.string(), v.uuid(), v.brand('CommandId'));
+const nonNegativeIntegerSchema = v.pipe(v.number(), v.integer(), v.minValue(0));
+const timestampSchema = v.pipe(v.string(), v.isoTimestamp());
+const threadIdsSchema = v.pipe(v.array(id.threadId.required()), v.minLength(1));
+const commandKinds = {
+    accountDelete: 'account.delete',
+    accountSettingsSet: 'account.settings.set',
+    aliasCreate: 'alias.create',
+    aliasDelete: 'alias.delete',
+    aliasNameSet: 'alias.name.set',
+    aliasPrimarySet: 'alias.primary.set',
+    aliasSignatureSet: 'alias.signature.set',
+    draftAttachmentDelete: 'draft.attachment.delete',
+    draftAttachmentLink: 'draft.attachment.link',
+    draftContentSet: 'draft.content.set',
+    draftCreate: 'draft.create',
+    draftDelete: 'draft.delete',
+    draftEnvelopeSet: 'draft.envelope.set',
+    draftFromSet: 'draft.from.set',
+    draftSend: 'draft.send',
+    draftSendCancel: 'draft.send.cancel',
+    draftSendSchedule: 'draft.send.schedule',
+    labelCreate: 'label.create',
+    labelDelete: 'label.delete',
+    labelRename: 'label.rename',
+    profileSettingsSet: 'profile.settings.set',
+    threadArchiveSet: 'thread.archive.set',
+    threadDelete: 'thread.delete',
+    threadFlaggedSet: 'thread.flagged.set',
+    threadLabelAdd: 'thread.label.add',
+    threadLabelRemove: 'thread.label.remove',
+    threadSeenSet: 'thread.seen.set',
+    threadSnoozeSet: 'thread.snooze.set',
+    threadSpamSet: 'thread.spam.set',
+    threadTrashSet: 'thread.trash.set',
+};
+const appwriteCommandKinds = [
+    commandKinds.profileSettingsSet,
+    commandKinds.accountSettingsSet,
+    commandKinds.accountDelete,
+    commandKinds.aliasCreate,
+    commandKinds.aliasDelete,
+    commandKinds.aliasNameSet,
+    commandKinds.aliasPrimarySet,
+    commandKinds.aliasSignatureSet,
+    commandKinds.labelCreate,
+    commandKinds.labelDelete,
+    commandKinds.labelRename,
+    commandKinds.threadLabelAdd,
+    commandKinds.threadLabelRemove,
+    commandKinds.threadArchiveSet,
+    commandKinds.threadFlaggedSet,
+    commandKinds.threadSeenSet,
+    commandKinds.threadSnoozeSet,
+    commandKinds.threadSpamSet,
+    commandKinds.threadTrashSet,
+    commandKinds.threadDelete,
+    commandKinds.draftCreate,
+    commandKinds.draftContentSet,
+    commandKinds.draftEnvelopeSet,
+    commandKinds.draftFromSet,
+    commandKinds.draftDelete,
+    commandKinds.draftAttachmentLink,
+    commandKinds.draftAttachmentDelete,
+    commandKinds.draftSend,
+    commandKinds.draftSendCancel,
+    commandKinds.draftSendSchedule,
+];
+const commandStates = ['ACCEPTED', 'RUNNING', 'SUCCEEDED', 'FAILED'];
+const commandErrorCodes = [
+    'AUTHENTICATION_FAILED',
+    'AUTHORIZATION_FAILED',
+    'COMMAND_CONFLICT',
+    'COMMAND_NOT_FOUND',
+    'INVALID_COMMAND',
+    'PROVIDER_REJECTED',
+    'TRANSIENT_FAILURE',
+    'INTERNAL_ERROR',
+];
+const accountIdSchema = id.accountId.required();
+const createCommandRequestSchema = (kind, payload, accountId) => v.strictObject({
+    accountId,
+    id: commandIdSchema,
+    kind: v.literal(kind),
+    payload,
+    submittedAt: timestampSchema,
+    version: v.literal(1),
+});
+const createAccountCommandRequestSchema = (kind, payload) => createCommandRequestSchema(kind, payload, accountIdSchema);
+const profileSettingsSetPayloadSchema = v.strictObject({
+    name: v.optional(v.nullable(string.required())),
+    timezone: v.optional(v.nullable(string.required())),
+});
+const accountSettingsSetPayloadSchema = v.strictObject({
+    colour: v.optional(string.required(64)),
+    displayName: v.optional(v.nullable(string.required())),
+});
+const accountDeletePayloadSchema = v.strictObject({});
+const aliasCreatePayloadSchema = v.strictObject({
+    aliasId: id.aliasId.required(),
+    email: string.email(),
+    name: v.nullable(string.required()),
+    signature: v.nullable(v.pipe(v.string(), v.maxLength(50_000))),
+});
+const aliasDeletePayloadSchema = v.strictObject({ aliasId: id.aliasId.required() });
+const aliasNameSetPayloadSchema = v.strictObject({
+    aliasId: id.aliasId.required(),
+    name: v.nullable(string.required()),
+});
+const aliasPrimarySetPayloadSchema = v.strictObject({ aliasId: id.aliasId.required() });
+const aliasSignatureSetPayloadSchema = v.strictObject({
+    aliasId: id.aliasId.required(),
+    signature: v.nullable(v.pipe(v.string(), v.maxLength(50_000))),
+});
+const labelCreatePayloadSchema = v.strictObject({ labelId: id.labelId.required(), path: string.required() });
+const labelDeletePayloadSchema = v.strictObject({ labelId: id.labelId.required() });
+const labelRenamePayloadSchema = v.strictObject({ labelId: id.labelId.required(), path: string.required() });
+const threadLabelAddPayloadSchema = v.strictObject({ labelId: id.labelId.required(), threadIds: threadIdsSchema });
+const threadLabelRemovePayloadSchema = v.strictObject({ labelId: id.labelId.required(), threadIds: threadIdsSchema });
+const threadArchiveSetPayloadSchema = v.strictObject({ archived: v.boolean(), threadIds: threadIdsSchema });
+const threadFlaggedSetPayloadSchema = v.strictObject({ flagged: v.boolean(), threadIds: threadIdsSchema });
+const threadSeenSetPayloadSchema = v.strictObject({ seen: v.boolean(), threadIds: threadIdsSchema });
+const threadSnoozeSetPayloadSchema = v.strictObject({
+    snoozedUntil: v.nullable(timestampSchema),
+    threadIds: threadIdsSchema,
+});
+const threadSpamSetPayloadSchema = v.strictObject({ spam: v.boolean(), threadIds: threadIdsSchema });
+const threadTrashSetPayloadSchema = v.strictObject({ threadIds: threadIdsSchema, trashed: v.boolean() });
+const threadDeletePayloadSchema = v.strictObject({ threadIds: threadIdsSchema });
+const draftCreatePayloadSchema = v.strictObject({
+    draftId: id.draftId.required(),
+    fromAliasId: v.nullable(id.aliasId.required()),
+    referencedMessageId: v.nullable(id.messageId.required()),
+    type: v.picklist(DRAFT_TYPES),
+});
+const draftContentSetPayloadSchema = v.strictObject({
+    draftId: id.draftId.required(),
+    html: v.pipe(v.string(), v.maxLength(384_000)),
+});
+const draftEnvelopeSetPayloadSchema = v.strictObject({
+    bcc: v.array(string.email()),
+    cc: v.array(string.email()),
+    draftId: id.draftId.required(),
+    subject: v.nullable(v.pipe(v.string(), v.maxLength(998))),
+    to: v.array(string.email()),
+});
+const draftFromSetPayloadSchema = v.strictObject({ draftId: id.draftId.required(), fromAliasId: id.aliasId.required() });
+const draftDeletePayloadSchema = v.strictObject({ draftId: id.draftId.required() });
+const draftAttachmentLinkPayloadSchema = v.strictObject({
+    draftId: id.draftId.required(),
+    fileId: string.required(36),
+    fileName: string.required(),
+    mimeType: string.required(),
+    size: nonNegativeIntegerSchema,
+});
+const draftAttachmentDeletePayloadSchema = v.strictObject({
+    draftId: id.draftId.required(),
+    fileId: string.required(36),
+});
+const draftSendPayloadSchema = v.strictObject({ draftId: id.draftId.required() });
+const draftSendCancelPayloadSchema = v.strictObject({ draftId: id.draftId.required() });
+const draftSendSchedulePayloadSchema = v.strictObject({ draftId: id.draftId.required(), scheduledAt: timestampSchema });
+const commandRequestSchemas = [
+    createCommandRequestSchema(commandKinds.profileSettingsSet, profileSettingsSetPayloadSchema, v.nullable(accountIdSchema)),
+    createAccountCommandRequestSchema(commandKinds.accountSettingsSet, accountSettingsSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.accountDelete, accountDeletePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.aliasCreate, aliasCreatePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.aliasDelete, aliasDeletePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.aliasNameSet, aliasNameSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.aliasPrimarySet, aliasPrimarySetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.aliasSignatureSet, aliasSignatureSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.labelCreate, labelCreatePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.labelDelete, labelDeletePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.labelRename, labelRenamePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.threadLabelAdd, threadLabelAddPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.threadLabelRemove, threadLabelRemovePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.threadArchiveSet, threadArchiveSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.threadFlaggedSet, threadFlaggedSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.threadSeenSet, threadSeenSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.threadSnoozeSet, threadSnoozeSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.threadSpamSet, threadSpamSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.threadTrashSet, threadTrashSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.threadDelete, threadDeletePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftCreate, draftCreatePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftContentSet, draftContentSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftEnvelopeSet, draftEnvelopeSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftFromSet, draftFromSetPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftDelete, draftDeletePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftAttachmentLink, draftAttachmentLinkPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftAttachmentDelete, draftAttachmentDeletePayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftSend, draftSendPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftSendCancel, draftSendCancelPayloadSchema),
+    createAccountCommandRequestSchema(commandKinds.draftSendSchedule, draftSendSchedulePayloadSchema),
+];
+const commandErrorSchema = v.strictObject({
+    code: v.picklist(commandErrorCodes),
+    retryable: v.boolean(),
+});
+const commandResponseSchemas = [
+    v.strictObject({
+        canonicalRevision: v.nullable(nonNegativeIntegerSchema),
+        error: v.null_(),
+        id: commandIdSchema,
+        state: v.literal('ACCEPTED'),
+    }),
+    v.strictObject({
+        canonicalRevision: v.nullable(nonNegativeIntegerSchema),
+        error: v.null_(),
+        id: commandIdSchema,
+        state: v.literal('RUNNING'),
+    }),
+    v.strictObject({
+        canonicalRevision: v.nullable(nonNegativeIntegerSchema),
+        error: v.null_(),
+        id: commandIdSchema,
+        state: v.literal('SUCCEEDED'),
+    }),
+    v.strictObject({
+        canonicalRevision: v.nullable(nonNegativeIntegerSchema),
+        error: commandErrorSchema,
+        id: commandIdSchema,
+        state: v.literal('FAILED'),
+    }),
+];
+export const appwriteCommands = {
+    errorCodes: commandErrorCodes,
+    errorSchema: commandErrorSchema,
+    kinds: appwriteCommandKinds,
+    requestSchema: v.variant('kind', commandRequestSchemas),
+    responseSchema: v.variant('state', commandResponseSchemas),
+    states: commandStates,
+    version: 1,
+};

package/dist/appwrite/commands.test.d.ts

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

package/dist/appwrite/commands.test.d.ts.map

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

package/dist/appwrite/commands.test.js

@@ -0,0 +1,381 @@
+import { describe, expect, it } from 'bun:test';
+import * as v from 'valibot';
+import { appwriteCommands } from './commands';
+const commandMetadata = {
+    id: '0197f3d4-1b22-7abc-8def-123456789abc',
+    submittedAt: '2026-07-15T00:00:00.000Z',
+    version: 1,
+};
+const commandFixtures = [
+    {
+        command: {
+            ...commandMetadata,
+            accountId: null,
+            kind: 'profile.settings.set',
+            payload: { name: 'Isaac', timezone: 'Europe/London' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'account.settings.set',
+            payload: { colour: '#000000', displayName: 'Marco' },
+        },
+    },
+    { command: { ...commandMetadata, accountId: 'account_1', kind: 'account.delete', payload: {} } },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'alias.create',
+            payload: { aliasId: 'alias_1', email: 'marco@example.com', name: null, signature: null },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'alias.delete',
+            payload: { aliasId: 'alias_1' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'alias.name.set',
+            payload: { aliasId: 'alias_1', name: 'Marco' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'alias.primary.set',
+            payload: { aliasId: 'alias_1' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'alias.signature.set',
+            payload: { aliasId: 'alias_1', signature: 'Regards' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'label.create',
+            payload: { labelId: 'label_1', path: 'Projects' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'label.delete',
+            payload: { labelId: 'label_1' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'label.rename',
+            payload: { labelId: 'label_1', path: 'Projects/Marco' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'thread.label.add',
+            payload: { labelId: 'label_1', threadIds: ['thread_1'] },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'thread.label.remove',
+            payload: { labelId: 'label_1', threadIds: ['thread_1'] },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'thread.archive.set',
+            payload: { archived: true, threadIds: ['thread_1'] },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'thread.flagged.set',
+            payload: { flagged: true, threadIds: ['thread_1'] },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'thread.seen.set',
+            payload: { seen: true, threadIds: ['thread_1'] },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'thread.snooze.set',
+            payload: { snoozedUntil: '2026-07-16T00:00:00.000Z', threadIds: ['thread_1'] },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'thread.spam.set',
+            payload: { spam: true, threadIds: ['thread_1'] },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'thread.trash.set',
+            payload: { threadIds: ['thread_1'], trashed: true },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'thread.delete',
+            payload: { threadIds: ['thread_1'] },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'draft.create',
+            payload: { draftId: 'draft_1', fromAliasId: null, referencedMessageId: null, type: 'NEW' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'draft.content.set',
+            payload: { draftId: 'draft_1', html: '<p>Hello</p>' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'draft.envelope.set',
+            payload: { bcc: [], cc: [], draftId: 'draft_1', subject: 'Hello', to: ['marco@example.com'] },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'draft.from.set',
+            payload: { draftId: 'draft_1', fromAliasId: 'alias_1' },
+        },
+    },
+    { command: { ...commandMetadata, accountId: 'account_1', kind: 'draft.delete', payload: { draftId: 'draft_1' } } },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'draft.attachment.link',
+            payload: {
+                draftId: 'draft_1',
+                fileId: 'file_1',
+                fileName: 'proposal.pdf',
+                mimeType: 'application/pdf',
+                size: 1,
+            },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'draft.attachment.delete',
+            payload: { draftId: 'draft_1', fileId: 'file_1' },
+        },
+    },
+    { command: { ...commandMetadata, accountId: 'account_1', kind: 'draft.send', payload: { draftId: 'draft_1' } } },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'draft.send.cancel',
+            payload: { draftId: 'draft_1' },
+        },
+    },
+    {
+        command: {
+            ...commandMetadata,
+            accountId: 'account_1',
+            kind: 'draft.send.schedule',
+            payload: { draftId: 'draft_1', scheduledAt: '2026-07-16T00:00:00.000Z' },
+        },
+    },
+];
+describe('appwriteCommands', () => {
+    it('publishes the complete version-one command and status manifest', () => {
+        expect(appwriteCommands.version).toBe(1);
+        expect(appwriteCommands.kinds).toEqual([
+            'profile.settings.set',
+            'account.settings.set',
+            'account.delete',
+            'alias.create',
+            'alias.delete',
+            'alias.name.set',
+            'alias.primary.set',
+            'alias.signature.set',
+            'label.create',
+            'label.delete',
+            'label.rename',
+            'thread.label.add',
+            'thread.label.remove',
+            'thread.archive.set',
+            'thread.flagged.set',
+            'thread.seen.set',
+            'thread.snooze.set',
+            'thread.spam.set',
+            'thread.trash.set',
+            'thread.delete',
+            'draft.create',
+            'draft.content.set',
+            'draft.envelope.set',
+            'draft.from.set',
+            'draft.delete',
+            'draft.attachment.link',
+            'draft.attachment.delete',
+            'draft.send',
+            'draft.send.cancel',
+            'draft.send.schedule',
+        ]);
+        expect(appwriteCommands.states).toEqual(['ACCEPTED', 'RUNNING', 'SUCCEEDED', 'FAILED']);
+        expect(appwriteCommands.errorCodes).toEqual([
+            'AUTHENTICATION_FAILED',
+            'AUTHORIZATION_FAILED',
+            'COMMAND_CONFLICT',
+            'COMMAND_NOT_FOUND',
+            'INVALID_COMMAND',
+            'PROVIDER_REJECTED',
+            'TRANSIENT_FAILURE',
+            'INTERNAL_ERROR',
+        ]);
+    });
+    for (const { command } of commandFixtures) {
+        it(`accepts ${command.kind}`, () => {
+            expect(v.safeParse(appwriteCommands.requestSchema, command).success).toBe(true);
+        });
+    }
+    const invalidCommands = [
+        {
+            command: { ...commandFixtures[0].command, payload: commandFixtures[1].command.payload },
+            description: 'a command and payload mismatch',
+        },
+        {
+            command: { ...commandFixtures[0].command, userId: 'another-user' },
+            description: 'a caller-provided owner',
+        },
+        {
+            command: { ...commandFixtures[1].command, accountId: null },
+            description: 'a null account ID for an account-scoped command',
+        },
+        {
+            command: {
+                ...commandFixtures[21].command,
+                payload: { ...commandFixtures[21].command.payload, credentials: 'secret' },
+            },
+            description: 'credentials in a payload',
+        },
+        {
+            command: {
+                ...commandFixtures[26].command,
+                payload: { ...commandFixtures[26].command.payload, token: 'secret' },
+            },
+            description: 'a token in a payload',
+        },
+        {
+            command: { ...commandFixtures[0].command, kind: 'saved-view.create' },
+            description: 'an excluded action family',
+        },
+        {
+            command: { ...commandFixtures[0].command, version: 2 },
+            description: 'an unknown command version',
+        },
+    ];
+    for (const { command, description } of invalidCommands) {
+        it(`rejects ${description}`, () => {
+            expect(v.safeParse(appwriteCommands.requestSchema, command).success).toBe(false);
+        });
+    }
+    const responseFixtures = [
+        {
+            expected: true,
+            response: {
+                canonicalRevision: null,
+                error: null,
+                id: commandMetadata.id,
+                state: 'ACCEPTED',
+            },
+        },
+        {
+            expected: true,
+            response: {
+                canonicalRevision: null,
+                error: null,
+                id: commandMetadata.id,
+                state: 'RUNNING',
+            },
+        },
+        {
+            expected: true,
+            response: {
+                canonicalRevision: 3,
+                error: null,
+                id: commandMetadata.id,
+                state: 'SUCCEEDED',
+            },
+        },
+        {
+            expected: true,
+            response: {
+                canonicalRevision: 3,
+                error: { code: 'PROVIDER_REJECTED', retryable: false },
+                id: commandMetadata.id,
+                state: 'FAILED',
+            },
+        },
+        {
+            expected: false,
+            response: {
+                canonicalRevision: null,
+                error: { code: 'UNSAFE_CODE', retryable: false },
+                id: commandMetadata.id,
+                state: 'FAILED',
+            },
+        },
+    ];
+    for (const { expected, response } of responseFixtures) {
+        it(`parses ${response.state} status as ${expected ? 'valid' : 'invalid'}`, () => {
+            expect(v.safeParse(appwriteCommands.responseSchema, response).success).toBe(expected);
+        });
+    }
+});

package/dist/appwrite/index.d.ts

@@ -1,2 +1,3 @@
 export { type AppwriteRow, type AppwriteRowTable, appwrite } from './appwrite';
+export { type AppwriteCommandError, type AppwriteCommandKind, type AppwriteCommandPayload, type AppwriteCommandRequest, type AppwriteCommandResponse, type AppwriteCommandState, appwriteCommands, } from './commands';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/appwrite/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/appwrite/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC9E,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,gBAAgB,GACjB,MAAM,YAAY,CAAA"}

package/dist/appwrite/index.js

@@ -1 +1,2 @@
 export { appwrite } from './appwrite';
+export { appwriteCommands, } from './commands';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { type AppwriteRow, type AppwriteRowTable, appwrite } from './appwrite';
+export { type AppwriteCommandError, type AppwriteCommandKind, type AppwriteCommandPayload, type AppwriteCommandRequest, type AppwriteCommandResponse, type AppwriteCommandState, type AppwriteRow, type AppwriteRowTable, appwrite, appwriteCommands, } from './appwrite';
 export { marcoConstants } from './constants';
 export { MARCO_ENV, MarcoEnvironment, marcoPublicConfig } from './marcoPublicConfig';
 export { type Account, type AccountAlias, type AccountId, type AccountLabel, type AliasId, type AttachmentId, type Contact, type ContactId, type Draft, type DraftAttachment, type DraftBody, type DraftId, type LabelId, type MessageId, marcoSchemas, type PushNotificationTokenId, type RecipientId, type Thread, type ThreadId, type ThreadMessage, type ThreadMessageAttachment, type ThreadMessageRecipient, type User, type UserId, type UserPushNotificationToken, type UserView, type ViewId, } from './schemas';

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -1,4 +1,4 @@
-export { appwrite } from './appwrite';
+export { appwrite, appwriteCommands, } from './appwrite';
 export { marcoConstants } from './constants';
 export { MARCO_ENV, marcoPublicConfig } from './marcoPublicConfig';
 export { marcoSchemas, } from './schemas';

package/dist/schemas/index.d.ts

@@ -601,7 +601,7 @@ export declare const marcoSchemas: {
                         bcc: string[];
                         cc: string[];
                         to: string[];
-                    }, import("valibot").StringIssue | import("valibot").ArrayIssue | import("valibot").ObjectIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").NonOptionalIssue | import("valibot").RfcEmailIssue<string>>;
+                    }, import("valibot").StringIssue | import("valibot").ArrayIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").NonOptionalIssue | import("valibot").RfcEmailIssue<string> | import("valibot").ObjectIssue>;
                     readonly '~types'?: {
                         readonly input: {
                             subject: string | null;
@@ -615,7 +615,7 @@ export declare const marcoSchemas: {
                             cc: string[];
                             to: string[];
                         };
-                        readonly issue: import("valibot").StringIssue | import("valibot").ArrayIssue | import("valibot").ObjectIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").NonOptionalIssue | import("valibot").RfcEmailIssue<string>;
+                        readonly issue: import("valibot").StringIssue | import("valibot").ArrayIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").NonOptionalIssue | import("valibot").RfcEmailIssue<string> | import("valibot").ObjectIssue;
                     } | 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, "DraftId">]>, undefined>;

package/dist/schemas/mutators/mutatorSchemas.d.ts

@@ -176,7 +176,7 @@ export declare const mutatorSchemas: {
                     bcc: string[];
                     cc: string[];
                     to: string[];
-                }, v.StringIssue | v.ArrayIssue | v.ObjectIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string>>;
+                }, v.StringIssue | v.ArrayIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string> | v.ObjectIssue>;
                 readonly '~types'?: {
                     readonly input: {
                         subject: string | null;
@@ -190,7 +190,7 @@ export declare const mutatorSchemas: {
                         cc: string[];
                         to: string[];
                     };
-                    readonly issue: v.StringIssue | v.ArrayIssue | v.ObjectIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string>;
+                    readonly issue: v.StringIssue | v.ArrayIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string> | v.ObjectIssue;
                 } | undefined;
             };
             readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;

package/dist/sdk/endpoints/private/mutations/draft/setEnvelope.d.ts

@@ -30,7 +30,7 @@ export declare const setEnvelope: import("../../../../..").EndpointConfig<"/v1/p
             bcc: string[];
             cc: string[];
             to: string[];
-        }, v.StringIssue | v.ArrayIssue | v.ObjectIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string>>;
+        }, v.StringIssue | v.ArrayIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string> | v.ObjectIssue>;
         readonly '~types'?: {
             readonly input: {
                 subject: string | null;
@@ -44,7 +44,7 @@ export declare const setEnvelope: import("../../../../..").EndpointConfig<"/v1/p
                 cc: string[];
                 to: string[];
             };
-            readonly issue: v.StringIssue | v.ArrayIssue | v.ObjectIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string>;
+            readonly issue: v.StringIssue | v.ArrayIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string> | v.ObjectIssue;
         } | undefined;
     };
     readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;

package/dist/types/index.d.ts

@@ -1,4 +1,3 @@
-export type { ReadonlyDeep } from 'type-fest';
 export * from './AuthData';
 export * from './DraftAttachmentUploadStatus';
 export * from './DraftStatus';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAE7C,cAAc,YAAY,CAAA;AAC1B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA"}

package/package.json

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