@remit/electrodb-entities 0.0.1

package/index.mjs

@@ -0,0 +1,4004 @@
+import { CustomAttributeType } from "electrodb";
+export const AccountExportRequest = {
+    attributes: {
+        accountExportRequestId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountExportRequestId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountExportRequestId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        userId: {
+            type: "string",
+            required: true
+        },
+        state: {
+            type: ["Pending", "Processing", "Ready", "Failed"],
+            required: true,
+            default: "Pending"
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        expiresAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'expiresAt' must be an integer");
+                return true;
+            }
+        },
+        objectKey: {
+            type: "string",
+            required: false
+        },
+        downloadUrl: {
+            type: "string",
+            required: false
+        },
+        errorMessage: {
+            type: "string",
+            required: false
+        }
+    },
+    indexes: {
+        byAccountConfigId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["createdAt"]
+            },
+            index: "gsi0"
+        },
+        AccountExportRequest: {
+            pk: {
+                field: "pk",
+                composite: ["accountExportRequestId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "accountExportRequest",
+        service: "remit",
+        version: "1"
+    }
+};
+export const AccountConfig = {
+    attributes: {
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        userId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'userId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'userId' must be at most 25 characters");
+                return true;
+            }
+        },
+        name: {
+            type: "string",
+            required: false
+        },
+        state: {
+            type: ["active", "deleting"],
+            required: true,
+            default: "active"
+        },
+        deletedAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'deletedAt' must be an integer");
+                return true;
+            }
+        },
+        cascadeStartedAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'cascadeStartedAt' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        allAccountConfigs: {
+            pk: {
+                field: "gsi2pk",
+                composite: []
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["accountConfigId"]
+            },
+            index: "gsi2"
+        },
+        byAccountConfigId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: []
+            },
+            index: "gsi1",
+            collection: "accountConfig"
+        },
+        byUserId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["userId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["accountConfigId"]
+            },
+            index: "gsi0"
+        },
+        AccountConfig: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "accountConfig",
+        service: "remit",
+        version: "1"
+    }
+};
+export const Account = {
+    attributes: {
+        accountId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        username: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 1)
+                    throw new Error("'username' must be at least 1 characters");
+                return true;
+            }
+        },
+        email: {
+            type: "string",
+            required: true
+        },
+        authType: {
+            type: ["password", "oauthMicrosoft"],
+            required: true,
+            default: "password"
+        },
+        passwordHash: {
+            type: "string",
+            required: false
+        },
+        oauthRefreshTokenHash: {
+            type: "string",
+            required: false
+        },
+        oauthTokenUpdatedAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'oauthTokenUpdatedAt' must be an integer");
+                return true;
+            }
+        },
+        imapHost: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 1)
+                    throw new Error("'imapHost' must be at least 1 characters");
+                return true;
+            }
+        },
+        imapPort: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 1)
+                    throw new Error("'imapPort' must be at least 1");
+                if (typeof value === "number" && value > 65535)
+                    throw new Error("'imapPort' must be at most 65535");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'imapPort' must be an integer");
+                return true;
+            }
+        },
+        imapTls: {
+            type: "boolean",
+            required: true
+        },
+        imapStartTls: {
+            type: "boolean",
+            required: true
+        },
+        smtpEnabled: {
+            type: "boolean",
+            required: true,
+            default: false
+        },
+        smtpHost: {
+            type: "string",
+            required: true,
+            default: ""
+        },
+        smtpPort: {
+            type: "number",
+            required: true,
+            default: 587,
+            validate: value => {
+                if (typeof value === "number" && value < 1)
+                    throw new Error("'smtpPort' must be at least 1");
+                if (typeof value === "number" && value > 65535)
+                    throw new Error("'smtpPort' must be at most 65535");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'smtpPort' must be an integer");
+                return true;
+            }
+        },
+        smtpTls: {
+            type: "boolean",
+            required: true,
+            default: false
+        },
+        smtpStartTls: {
+            type: "boolean",
+            required: true,
+            default: true
+        },
+        smtpUsername: {
+            type: "string",
+            required: true,
+            default: ""
+        },
+        smtpPasswordHash: {
+            type: "string",
+            required: false
+        },
+        isActive: {
+            type: "boolean",
+            required: true
+        },
+        connectionState: {
+            type: ["not_authenticated", "authenticated", "selected", "logout", "reauth_required"],
+            required: true
+        },
+        lastConnectedAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lastConnectedAt' must be an integer");
+                return true;
+            }
+        },
+        lastSyncAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lastSyncAt' must be an integer");
+                return true;
+            }
+        },
+        lastError: {
+            type: "string",
+            required: false
+        },
+        syncPhase: {
+            type: ["idle", "discovering_mailboxes", "syncing_inbox", "syncing_others", "complete", "error"],
+            required: false
+        },
+        mailboxCountTotal: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'mailboxCountTotal' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'mailboxCountTotal' must be an integer");
+                return true;
+            }
+        },
+        mailboxCountSynced: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'mailboxCountSynced' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'mailboxCountSynced' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        deletedAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'deletedAt' must be an integer");
+                return true;
+            }
+        }
+    },
+    indexes: {
+        allAccounts: {
+            pk: {
+                field: "gsi2pk",
+                composite: []
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["accountId"]
+            },
+            index: "gsi2"
+        },
+        byAccountId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: []
+            },
+            index: "gsi0",
+            collection: "account"
+        },
+        byAccountConfigId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["accountId"]
+            },
+            index: "gsi1",
+            collection: "accountConfig"
+        },
+        Account: {
+            pk: {
+                field: "pk",
+                composite: ["accountId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "account",
+        service: "remit",
+        version: "1"
+    }
+};
+export const Mailbox = {
+    attributes: {
+        mailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountId' must be at most 25 characters");
+                return true;
+            }
+        },
+        namespaceType: {
+            type: ["personal", "other_users", "shared"],
+            required: true,
+            default: "personal"
+        },
+        namespacePrefix: {
+            type: "string",
+            required: true
+        },
+        hierarchyDelimiter: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 1)
+                    throw new Error("'hierarchyDelimiter' must be at least 1 characters");
+                if (typeof value === "string" && value.length > 1)
+                    throw new Error("'hierarchyDelimiter' must be at most 1 characters");
+                return true;
+            }
+        },
+        fullPath: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 1)
+                    throw new Error("'fullPath' must be at least 1 characters");
+                if (typeof value === "string" && value.length > 512)
+                    throw new Error("'fullPath' must be at most 512 characters");
+                return true;
+            }
+        },
+        uidValidity: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 1)
+                    throw new Error("'uidValidity' must be at least 1");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'uidValidity' must be an integer");
+                return true;
+            }
+        },
+        uidNext: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 1)
+                    throw new Error("'uidNext' must be at least 1");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'uidNext' must be an integer");
+                return true;
+            }
+        },
+        highestModseq: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'highestModseq' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'highestModseq' must be an integer");
+                return true;
+            }
+        },
+        messageCount: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'messageCount' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'messageCount' must be an integer");
+                return true;
+            }
+        },
+        unseenCount: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'unseenCount' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'unseenCount' must be an integer");
+                return true;
+            }
+        },
+        deletedCount: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'deletedCount' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'deletedCount' must be an integer");
+                return true;
+            }
+        },
+        totalSize: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'totalSize' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'totalSize' must be an integer");
+                return true;
+            }
+        },
+        lastSyncUid: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lastSyncUid' must be an integer");
+                return true;
+            }
+        },
+        highWaterMarkUid: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'highWaterMarkUid' must be an integer");
+                return true;
+            }
+        },
+        lastMessageSyncAt: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lastMessageSyncAt' must be an integer");
+                return true;
+            }
+        },
+        initialSyncCompletedAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'initialSyncCompletedAt' must be an integer");
+                return true;
+            }
+        },
+        parentMailboxId: {
+            type: "string",
+            required: true,
+            default: "None"
+        },
+        syncStatus: {
+            type: ["synced", "pending", "failed", "deleting"],
+            required: false
+        },
+        cursorState: {
+            type: ["normal", "cursor_invalid", "rebuilding"],
+            required: true,
+            default: "normal"
+        },
+        oldPath: {
+            type: "string",
+            required: false,
+            validate: value => {
+                if (typeof value === "string" && value.length > 512)
+                    throw new Error("'oldPath' must be at most 512 characters");
+                return true;
+            }
+        },
+        specialUse: {
+            type: "set",
+            items: ["All", "Archive", "Drafts", "Flagged", "Junk", "Sent", "Trash", "Important"],
+            set: value => Array.isArray(value) && value.length === 0 ? undefined : value,
+            required: false
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMailboxId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["mailboxId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: []
+            },
+            index: "gsi1",
+            collection: "mailbox"
+        },
+        byAccountId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: []
+            },
+            index: "gsi0",
+            collection: "account"
+        },
+        Mailbox: {
+            pk: {
+                field: "pk",
+                composite: ["mailboxId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "mailbox",
+        service: "remit",
+        version: "1"
+    }
+};
+export const Filter = {
+    attributes: {
+        filterId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'filterId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'filterId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        name: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 256)
+                    throw new Error("'name' must be at most 256 characters");
+                return true;
+            }
+        },
+        scope: {
+            type: ["Standing", "Temporary"],
+            required: true
+        },
+        expiresAt: {
+            type: "string",
+            required: false
+        },
+        ttl: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'ttl' must be an integer");
+                return true;
+            }
+        },
+        state: {
+            type: ["Active", "Expired"],
+            required: true,
+            default: "Active"
+        },
+        hasAnchor: {
+            type: "boolean",
+            required: true,
+            default: false
+        },
+        ruleChangedAt: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'ruleChangedAt' must be an integer");
+                return true;
+            }
+        },
+        matchOperator: {
+            type: ["And", "Or"],
+            required: true,
+            default: "And"
+        },
+        literalClauses: {
+            type: "list",
+            items: {
+                type: "map",
+                properties: {
+                    field: {
+                        type: ["From", "Subject", "HasWords"],
+                        required: true
+                    },
+                    value: {
+                        type: "string",
+                        required: true
+                    }
+                }
+            },
+            required: true
+        },
+        actionLabelId: {
+            type: "string",
+            required: true,
+            default: "None"
+        },
+        actionMailboxId: {
+            type: "string",
+            required: true,
+            default: "None"
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byAccountAndState: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["state", "filterId"]
+            },
+            index: "gsi1"
+        },
+        Filter: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "sk",
+                composite: ["filterId"]
+            }
+        }
+    },
+    model: {
+        entity: "filter",
+        service: "remit",
+        version: "1"
+    }
+};
+export const OrganizeJobRequest = {
+    attributes: {
+        organizeJobId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'organizeJobId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'organizeJobId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        userId: {
+            type: "string",
+            required: true
+        },
+        state: {
+            type: ["Pending", "Running", "Complete", "Failed"],
+            required: true,
+            default: "Pending"
+        },
+        anchorMessageId: {
+            type: "string",
+            required: true,
+            default: "None"
+        },
+        matchOperator: {
+            type: ["And", "Or"],
+            required: true,
+            default: "And"
+        },
+        literalClauses: {
+            type: "list",
+            items: {
+                type: "map",
+                properties: {
+                    field: {
+                        type: ["From", "Subject", "HasWords"],
+                        required: true
+                    },
+                    value: {
+                        type: "string",
+                        required: true
+                    }
+                }
+            },
+            required: true
+        },
+        similarityThreshold: {
+            type: "number",
+            required: true,
+            default: 0.75,
+            validate: value => {
+                if (typeof value === "number" && !Number.isFinite(value))
+                    throw new Error("'similarityThreshold' must be a finite number");
+                return true;
+            }
+        },
+        actionLabelId: {
+            type: "string",
+            required: true,
+            default: "None"
+        },
+        actionMailboxId: {
+            type: "string",
+            required: true,
+            default: "None"
+        },
+        matchedCount: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'matchedCount' must be an integer");
+                return true;
+            }
+        },
+        appliedCount: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'appliedCount' must be an integer");
+                return true;
+            }
+        },
+        failedCount: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'failedCount' must be an integer");
+                return true;
+            }
+        },
+        errorMessage: {
+            type: "string",
+            required: true,
+            default: ""
+        },
+        ttl: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'ttl' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byAccountConfigId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["createdAt"]
+            },
+            index: "gsi0"
+        },
+        OrganizeJobRequest: {
+            pk: {
+                field: "pk",
+                composite: ["organizeJobId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "organizeJobRequest",
+        service: "remit",
+        version: "1"
+    }
+};
+export const ThreadMessage = {
+    attributes: {
+        threadMessageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'threadMessageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'threadMessageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        threadId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'threadId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'threadId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        mailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        uid: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 1)
+                    throw new Error("'uid' must be at least 1");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'uid' must be an integer");
+                return true;
+            }
+        },
+        messageIdHeader: {
+            type: "string",
+            required: false
+        },
+        inReplyTo: {
+            type: "string",
+            required: false
+        },
+        referenceOrder: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'referenceOrder' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'referenceOrder' must be an integer");
+                return true;
+            }
+        },
+        fromEmail: {
+            type: "string",
+            required: false
+        },
+        fromName: {
+            type: "string",
+            required: false
+        },
+        subject: {
+            type: "string",
+            required: false
+        },
+        internalDate: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'internalDate' must be an integer");
+                return true;
+            }
+        },
+        sentDate: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'sentDate' must be an integer");
+                return true;
+            }
+        },
+        isRead: {
+            type: "boolean",
+            required: true
+        },
+        hasAttachment: {
+            type: "boolean",
+            required: true
+        },
+        star: {
+            type: ["none", "yellow", "orange", "red", "purple", "blue", "teal", "green", "yellow_bang", "red_bang", "purple_question", "blue_info", "orange_guillemet", "green_check", "yellow_check", "blue_star"],
+            required: true,
+            default: "none"
+        },
+        hasStars: {
+            type: "boolean",
+            required: true
+        },
+        isDeleted: {
+            type: "boolean",
+            required: true
+        },
+        snippet: {
+            type: "string",
+            required: false,
+            validate: value => {
+                if (typeof value === "string" && value.length > 256)
+                    throw new Error("'snippet' must be at most 256 characters");
+                return true;
+            }
+        },
+        category: {
+            type: ["uncategorized", "personal", "newsletter", "marketing", "automated", "transactional", "social"],
+            required: true,
+            default: "uncategorized"
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMailboxAndReadStatus: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "lsi5sk",
+                composite: ["mailboxId", "isRead", "sentDate"]
+            },
+            index: "lsi5"
+        },
+        byStarred: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "lsi4sk",
+                composite: ["hasStars", "sentDate"]
+            },
+            index: "lsi4"
+        },
+        byAttachment: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "lsi3sk",
+                composite: ["hasAttachment", "sentDate"]
+            },
+            index: "lsi3"
+        },
+        byMailboxId: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "lsi2sk",
+                composite: ["mailboxId", "sentDate"]
+            },
+            index: "lsi2"
+        },
+        byDate: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "lsi1sk",
+                composite: ["sentDate"]
+            },
+            index: "lsi1"
+        },
+        byUnread: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["isRead", "sentDate"]
+            },
+            index: "gsi2"
+        },
+        byMessageId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: []
+            },
+            index: "gsi1"
+        },
+        byThreadId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["threadId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["sentDate"]
+            },
+            index: "gsi0",
+            collection: "threadDetails"
+        },
+        ThreadMessage: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "sk",
+                composite: ["threadMessageId"]
+            }
+        }
+    },
+    model: {
+        entity: "threadMessage",
+        service: "remit",
+        version: "1"
+    }
+};
+export const OutboxMessage = {
+    attributes: {
+        outboxMessageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'outboxMessageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'outboxMessageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        fromAddress: {
+            type: "string",
+            required: true
+        },
+        fromName: {
+            type: "string",
+            required: false
+        },
+        toAddresses: {
+            type: "list",
+            items: {
+                type: "string"
+            },
+            required: true
+        },
+        ccAddresses: {
+            type: "list",
+            items: {
+                type: "string"
+            },
+            required: true
+        },
+        bccAddresses: {
+            type: "list",
+            items: {
+                type: "string"
+            },
+            required: true
+        },
+        replyToAddress: {
+            type: "string",
+            required: false
+        },
+        subject: {
+            type: "string",
+            required: false
+        },
+        messageIdValue: {
+            type: "string",
+            required: true
+        },
+        inReplyTo: {
+            type: "string",
+            required: false
+        },
+        references: {
+            type: "list",
+            items: {
+                type: "string"
+            },
+            required: true
+        },
+        textBody: {
+            type: "string",
+            required: false
+        },
+        htmlBody: {
+            type: "string",
+            required: false
+        },
+        status: {
+            type: ["draft", "queued", "sending", "sent", "failed", "blocked"],
+            required: true
+        },
+        lastError: {
+            type: "string",
+            required: false
+        },
+        lastSmtpCode: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lastSmtpCode' must be an integer");
+                return true;
+            }
+        },
+        sentAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'sentAt' must be an integer");
+                return true;
+            }
+        },
+        smtpMessageId: {
+            type: "string",
+            required: false
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byAccountId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["createdAt"]
+            },
+            index: "gsi0"
+        },
+        OutboxMessage: {
+            pk: {
+                field: "pk",
+                composite: ["outboxMessageId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "outboxMessage",
+        service: "remit",
+        version: "1"
+    }
+};
+export const Address = {
+    attributes: {
+        addressId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'addressId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'addressId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        displayName: {
+            type: "string",
+            required: false
+        },
+        localPart: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 1)
+                    throw new Error("'localPart' must be at least 1 characters");
+                return true;
+            }
+        },
+        domain: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 1)
+                    throw new Error("'domain' must be at least 1 characters");
+                return true;
+            }
+        },
+        normalizedEmail: {
+            type: "string",
+            required: true
+        },
+        normalizedCompound: {
+            type: "string",
+            required: true
+        },
+        flags: {
+            type: "map",
+            properties: {
+                trusted: {
+                    type: "map",
+                    properties: {
+                        value: {
+                            type: "boolean",
+                            required: true
+                        },
+                        setAt: {
+                            type: "number",
+                            required: true
+                        },
+                        setBy: {
+                            type: "string",
+                            required: false
+                        },
+                        expiresAt: {
+                            type: "number",
+                            required: false
+                        },
+                        reason: {
+                            type: "string",
+                            required: false
+                        }
+                    },
+                    required: false
+                },
+                blocked: {
+                    type: "map",
+                    properties: {
+                        value: {
+                            type: "boolean",
+                            required: true
+                        },
+                        setAt: {
+                            type: "number",
+                            required: true
+                        },
+                        setBy: {
+                            type: "string",
+                            required: false
+                        },
+                        expiresAt: {
+                            type: "number",
+                            required: false
+                        },
+                        reason: {
+                            type: "string",
+                            required: false
+                        }
+                    },
+                    required: false
+                },
+                muted: {
+                    type: "map",
+                    properties: {
+                        value: {
+                            type: "boolean",
+                            required: true
+                        },
+                        setAt: {
+                            type: "number",
+                            required: true
+                        },
+                        setBy: {
+                            type: "string",
+                            required: false
+                        },
+                        expiresAt: {
+                            type: "number",
+                            required: false
+                        },
+                        reason: {
+                            type: "string",
+                            required: false
+                        }
+                    },
+                    required: false
+                },
+                vip: {
+                    type: "map",
+                    properties: {
+                        value: {
+                            type: "boolean",
+                            required: true
+                        },
+                        setAt: {
+                            type: "number",
+                            required: true
+                        },
+                        setBy: {
+                            type: "string",
+                            required: false
+                        },
+                        expiresAt: {
+                            type: "number",
+                            required: false
+                        },
+                        reason: {
+                            type: "string",
+                            required: false
+                        }
+                    },
+                    required: false
+                },
+                wellknown: {
+                    type: "map",
+                    properties: {
+                        value: {
+                            type: "boolean",
+                            required: true
+                        },
+                        setAt: {
+                            type: "number",
+                            required: true
+                        },
+                        setBy: {
+                            type: "string",
+                            required: false
+                        },
+                        expiresAt: {
+                            type: "number",
+                            required: false
+                        },
+                        reason: {
+                            type: "string",
+                            required: false
+                        }
+                    },
+                    required: false
+                },
+                category: {
+                    type: "map",
+                    properties: {
+                        value: {
+                            type: ["uncategorized", "personal", "newsletter", "marketing", "automated", "transactional", "social"],
+                            required: true
+                        },
+                        setAt: {
+                            type: "number",
+                            required: true
+                        },
+                        setBy: {
+                            type: "string",
+                            required: false
+                        },
+                        expiresAt: {
+                            type: "number",
+                            required: false
+                        },
+                        reason: {
+                            type: "string",
+                            required: false
+                        }
+                    },
+                    required: false
+                },
+                autoArchive: {
+                    type: "map",
+                    properties: {
+                        value: {
+                            type: "boolean",
+                            required: true
+                        },
+                        setAt: {
+                            type: "number",
+                            required: true
+                        },
+                        setBy: {
+                            type: "string",
+                            required: false
+                        },
+                        expiresAt: {
+                            type: "number",
+                            required: false
+                        },
+                        reason: {
+                            type: "string",
+                            required: false
+                        }
+                    },
+                    required: false
+                },
+                unsubscribed: {
+                    type: "map",
+                    properties: {
+                        value: {
+                            type: "boolean",
+                            required: true
+                        },
+                        setAt: {
+                            type: "number",
+                            required: true
+                        },
+                        setBy: {
+                            type: "string",
+                            required: false
+                        },
+                        expiresAt: {
+                            type: "number",
+                            required: false
+                        },
+                        reason: {
+                            type: "string",
+                            required: false
+                        }
+                    },
+                    required: false
+                }
+            },
+            required: true
+        },
+        inboundCount: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'inboundCount' must be an integer");
+                return true;
+            }
+        },
+        outboundCount: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'outboundCount' must be an integer");
+                return true;
+            }
+        },
+        replyCount: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'replyCount' must be an integer");
+                return true;
+            }
+        },
+        lastInboundAt: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lastInboundAt' must be an integer");
+                return true;
+            }
+        },
+        lastOutboundAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lastOutboundAt' must be an integer");
+                return true;
+            }
+        },
+        lastReplyAt: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lastReplyAt' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byAccountConfigId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["normalizedCompound"]
+            },
+            index: "gsi1",
+            collection: "accountConfig"
+        },
+        Address: {
+            pk: {
+                field: "pk",
+                composite: ["addressId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "address",
+        service: "remit",
+        version: "1"
+    }
+};
+export const Message = {
+    attributes: {
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        mailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        uid: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 1)
+                    throw new Error("'uid' must be at least 1");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'uid' must be an integer");
+                return true;
+            }
+        },
+        sequenceNumber: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 1)
+                    throw new Error("'sequenceNumber' must be at least 1");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'sequenceNumber' must be an integer");
+                return true;
+            }
+        },
+        rfc822Size: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'rfc822Size' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'rfc822Size' must be an integer");
+                return true;
+            }
+        },
+        internalDate: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'internalDate' must be an integer");
+                return true;
+            }
+        },
+        messageIdHeader: {
+            type: "string",
+            required: false
+        },
+        envelopeId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'envelopeId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'envelopeId' must be at most 25 characters");
+                return true;
+            }
+        },
+        rootBodyPartId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'rootBodyPartId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'rootBodyPartId' must be at most 25 characters");
+                return true;
+            }
+        },
+        bodyStorageKey: {
+            type: "string",
+            required: false
+        },
+        status: {
+            type: ["active", "deleting", "deleted", "moving"],
+            required: true,
+            default: "active"
+        },
+        syncStatus: {
+            type: ["synced", "pending", "failed"],
+            required: true,
+            default: "synced"
+        },
+        originalMailboxId: {
+            type: "string",
+            required: false,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'originalMailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'originalMailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        originalUid: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'originalUid' must be an integer");
+                return true;
+            }
+        },
+        category: {
+            type: ["uncategorized", "personal", "newsletter", "marketing", "automated", "transactional", "social"],
+            required: true,
+            default: "uncategorized"
+        },
+        authenticity: {
+            type: "map",
+            properties: {
+                fromDomain: {
+                    type: "string",
+                    required: true
+                },
+                dkimDomain: {
+                    type: "string",
+                    required: false
+                },
+                dkimMismatch: {
+                    type: "boolean",
+                    required: true
+                }
+            },
+            required: false
+        },
+        authResult: {
+            type: "map",
+            properties: {
+                dmarc: {
+                    type: ["Pass", "Fail", "None", "Neutral", "Softfail"],
+                    required: false
+                },
+                spf: {
+                    type: ["Pass", "Fail", "None", "Neutral", "Softfail"],
+                    required: false
+                },
+                dkim: {
+                    type: ["Pass", "Fail", "None", "Neutral", "Softfail"],
+                    required: false
+                }
+            },
+            required: false
+        },
+        providerSpam: {
+            type: "map",
+            properties: {
+                classified: {
+                    type: "boolean",
+                    required: true
+                },
+                score: {
+                    type: "string",
+                    required: false
+                },
+                source: {
+                    type: "string",
+                    required: false
+                }
+            },
+            required: false
+        },
+        hasListUnsubscribe: {
+            type: "boolean",
+            required: true,
+            default: false
+        },
+        movedByRemit: {
+            type: "boolean",
+            required: true,
+            default: false
+        },
+        placementVerdict: {
+            type: "map",
+            properties: {
+                action: {
+                    type: ["MoveToInbox", "MoveToJunk"],
+                    required: true
+                },
+                confidence: {
+                    type: ["Confident", "Unsure"],
+                    required: true
+                },
+                fromPlacement: {
+                    type: "string",
+                    required: true
+                },
+                reasons: {
+                    type: "list",
+                    items: {
+                        type: "string"
+                    },
+                    required: true
+                },
+                dryRun: {
+                    type: "boolean",
+                    required: true
+                },
+                decidedAt: {
+                    type: "number",
+                    required: true
+                }
+            },
+            required: false
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: []
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        byMailboxId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["mailboxId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["uid"]
+            },
+            index: "gsi0",
+            collection: "message"
+        },
+        Message: {
+            pk: {
+                field: "pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "message",
+        service: "remit",
+        version: "1"
+    }
+};
+export const BodyPart = {
+    attributes: {
+        bodyPartId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'bodyPartId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'bodyPartId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        parentBodyPartId: {
+            type: "string",
+            required: false,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'parentBodyPartId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'parentBodyPartId' must be at most 25 characters");
+                return true;
+            }
+        },
+        partPath: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 1)
+                    throw new Error("'partPath' must be at least 1 characters");
+                return true;
+            }
+        },
+        mediaType: {
+            type: ["TEXT", "IMAGE", "AUDIO", "VIDEO", "APPLICATION", "MULTIPART", "MESSAGE"],
+            required: true
+        },
+        mediaSubtype: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 1)
+                    throw new Error("'mediaSubtype' must be at least 1 characters");
+                return true;
+            }
+        },
+        contentId: {
+            type: "string",
+            required: false
+        },
+        contentDescription: {
+            type: "string",
+            required: false
+        },
+        transferEncoding: {
+            type: ["7BIT", "8BIT", "BINARY", "BASE64", "QUOTED-PRINTABLE"],
+            required: true
+        },
+        sizeOctets: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'sizeOctets' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'sizeOctets' must be an integer");
+                return true;
+            }
+        },
+        lineCount: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lineCount' must be an integer");
+                return true;
+            }
+        },
+        md5Hash: {
+            type: "string",
+            required: false
+        },
+        disposition: {
+            type: ["inline", "attachment"],
+            required: false
+        },
+        dispositionFilename: {
+            type: "string",
+            required: false
+        },
+        language: {
+            type: "string",
+            required: false
+        },
+        location: {
+            type: "string",
+            required: false
+        },
+        isMultipart: {
+            type: "boolean",
+            required: true
+        },
+        multipartSubtype: {
+            type: ["mixed", "alternative", "digest", "parallel", "related", "signed", "encrypted", "form-data", "report"],
+            required: false
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["bodyPartId"]
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        BodyPart: {
+            pk: {
+                field: "pk",
+                composite: ["bodyPartId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "bodyPart",
+        service: "remit",
+        version: "1"
+    }
+};
+export const MessageReference = {
+    attributes: {
+        messageReferenceId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageReferenceId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageReferenceId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        envelopeId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'envelopeId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'envelopeId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageIdValue: {
+            type: "string",
+            required: true
+        },
+        referenceType: {
+            type: ["in_reply_to", "references"],
+            required: true
+        },
+        referenceOrder: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'referenceOrder' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'referenceOrder' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["messageReferenceId"]
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        MessageReference: {
+            pk: {
+                field: "pk",
+                composite: ["messageReferenceId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "messageReference",
+        service: "remit",
+        version: "1"
+    }
+};
+export const EnvelopeAddress = {
+    attributes: {
+        envelopeAddressId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'envelopeAddressId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'envelopeAddressId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        addressId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'addressId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'addressId' must be at most 25 characters");
+                return true;
+            }
+        },
+        displayName: {
+            type: "string",
+            required: false
+        },
+        normalizedEmail: {
+            type: "string",
+            required: true
+        },
+        addressRole: {
+            type: ["from", "sender", "reply_to", "to", "cc", "bcc"],
+            required: true
+        },
+        addressOrder: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'addressOrder' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'addressOrder' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["envelopeAddressId"]
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        EnvelopeAddress: {
+            pk: {
+                field: "pk",
+                composite: ["envelopeAddressId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "envelopeAddress",
+        service: "remit",
+        version: "1"
+    }
+};
+export const AccountSetting = {
+    attributes: {
+        accountSettingId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountSettingId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountSettingId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        name: {
+            type: "string",
+            required: true
+        },
+        value: {
+            type: CustomAttributeType("any"),
+            required: true
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byAccountConfigId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["name"]
+            },
+            index: "gsi0"
+        },
+        AccountSetting: {
+            pk: {
+                field: "pk",
+                composite: ["accountSettingId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "accountSetting",
+        service: "remit",
+        version: "1"
+    }
+};
+export const MailboxAttributeEntry = {
+    attributes: {
+        mailboxAttributeId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxAttributeId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxAttributeId' must be at most 25 characters");
+                return true;
+            }
+        },
+        mailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        attributeName: {
+            type: ["\NonExistent", "\Noinferiors", "\Noselect", "\HasChildren", "\HasNoChildren", "\Marked", "\Unmarked", "\Subscribed", "\Remote"],
+            required: true
+        }
+    },
+    indexes: {
+        byMailboxId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["mailboxId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["mailboxAttributeId"]
+            },
+            index: "gsi1",
+            collection: "mailbox"
+        },
+        MailboxAttributeEntry: {
+            pk: {
+                field: "pk",
+                composite: ["mailboxAttributeId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "mailboxAttributeEntry",
+        service: "remit",
+        version: "1"
+    }
+};
+export const MailboxSpecialUseEntry = {
+    attributes: {
+        mailboxSpecialUseId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxSpecialUseId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxSpecialUseId' must be at most 25 characters");
+                return true;
+            }
+        },
+        mailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        specialUse: {
+            type: ["All", "Archive", "Drafts", "Flagged", "Junk", "Sent", "Trash", "Important"],
+            required: true
+        }
+    },
+    indexes: {
+        byMailboxId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["mailboxId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["mailboxSpecialUseId"]
+            },
+            index: "gsi1",
+            collection: "mailbox"
+        },
+        MailboxSpecialUseEntry: {
+            pk: {
+                field: "pk",
+                composite: ["mailboxSpecialUseId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "mailboxSpecialUseEntry",
+        service: "remit",
+        version: "1"
+    }
+};
+export const MailboxFlag = {
+    attributes: {
+        mailboxFlagId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxFlagId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxFlagId' must be at most 25 characters");
+                return true;
+            }
+        },
+        mailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        flagName: {
+            type: CustomAttributeType("any"),
+            required: true
+        },
+        isPermanent: {
+            type: "boolean",
+            required: true
+        }
+    },
+    indexes: {
+        byMailboxId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["mailboxId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["mailboxFlagId"]
+            },
+            index: "gsi1",
+            collection: "mailbox"
+        },
+        MailboxFlag: {
+            pk: {
+                field: "pk",
+                composite: ["mailboxFlagId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "mailboxFlag",
+        service: "remit",
+        version: "1"
+    }
+};
+export const MailboxLock = {
+    attributes: {
+        mailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        eventName: {
+            type: "string",
+            required: true
+        },
+        accountId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountId' must be at most 25 characters");
+                return true;
+            }
+        },
+        lockId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'lockId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'lockId' must be at most 25 characters");
+                return true;
+            }
+        },
+        acquiredAt: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'acquiredAt' must be an integer");
+                return true;
+            }
+        },
+        lockedBy: {
+            type: "string",
+            required: true
+        },
+        ttl: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'ttl' must be an integer");
+                return true;
+            }
+        }
+    },
+    indexes: {
+        allLocks: {
+            pk: {
+                field: "gsi2pk",
+                composite: []
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["acquiredAt"]
+            },
+            index: "gsi2",
+            collection: "locks"
+        },
+        byAccountId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["accountId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["mailboxId", "eventName"]
+            },
+            index: "gsi1"
+        },
+        MailboxLock: {
+            pk: {
+                field: "pk",
+                composite: ["mailboxId"]
+            },
+            sk: {
+                field: "sk",
+                composite: ["eventName"]
+            }
+        }
+    },
+    model: {
+        entity: "mailboxLock",
+        service: "remit",
+        version: "1"
+    }
+};
+export const MessageFlag = {
+    attributes: {
+        messageFlagId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageFlagId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageFlagId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        flagName: {
+            type: CustomAttributeType("any"),
+            required: true
+        },
+        setAt: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'setAt' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["messageFlagId"]
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        MessageFlag: {
+            pk: {
+                field: "pk",
+                composite: ["messageFlagId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "messageFlag",
+        service: "remit",
+        version: "1"
+    }
+};
+export const MessagePlacementMove = {
+    attributes: {
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        sourceMailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'sourceMailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'sourceMailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        destinationMailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'destinationMailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'destinationMailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        state: {
+            type: ["pending", "queued", "processing", "processed"],
+            required: true,
+            default: "pending"
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byAccountId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["messageId"]
+            },
+            index: "gsi0"
+        },
+        MessagePlacementMove: {
+            pk: {
+                field: "pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "messagePlacementMove",
+        service: "remit",
+        version: "1"
+    }
+};
+export const MessageFlagPush = {
+    attributes: {
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        flagName: {
+            type: "string",
+            required: true
+        },
+        accountId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        mailboxId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'mailboxId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'mailboxId' must be at most 25 characters");
+                return true;
+            }
+        },
+        operation: {
+            type: ["add", "remove"],
+            required: true
+        },
+        state: {
+            type: ["pending", "queued", "processing", "processed"],
+            required: true,
+            default: "pending"
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMailboxId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["mailboxId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["messageId", "flagName"]
+            },
+            index: "gsi1"
+        },
+        byAccountId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["messageId", "flagName"]
+            },
+            index: "gsi0"
+        },
+        MessageFlagPush: {
+            pk: {
+                field: "pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "sk",
+                composite: ["flagName"]
+            }
+        }
+    },
+    model: {
+        entity: "messageFlagPush",
+        service: "remit",
+        version: "1"
+    }
+};
+export const Envelope = {
+    attributes: {
+        envelopeId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'envelopeId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'envelopeId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        dateValue: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'dateValue' must be an integer");
+                return true;
+            }
+        },
+        dateRaw: {
+            type: "string",
+            required: true
+        },
+        subject: {
+            type: "string",
+            required: false
+        },
+        messageIdValue: {
+            type: "string",
+            required: false
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["envelopeId"]
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        Envelope: {
+            pk: {
+                field: "pk",
+                composite: ["envelopeId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "envelope",
+        service: "remit",
+        version: "1"
+    }
+};
+export const BodyPartParameter = {
+    attributes: {
+        bodyPartParameterId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'bodyPartParameterId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'bodyPartParameterId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        bodyPartId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'bodyPartId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'bodyPartId' must be at most 25 characters");
+                return true;
+            }
+        },
+        parameterName: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 1)
+                    throw new Error("'parameterName' must be at least 1 characters");
+                return true;
+            }
+        },
+        parameterValue: {
+            type: "string",
+            required: true
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["bodyPartParameterId"]
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        BodyPartParameter: {
+            pk: {
+                field: "pk",
+                composite: ["bodyPartParameterId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "bodyPartParameter",
+        service: "remit",
+        version: "1"
+    }
+};
+export const RawMessageStorage = {
+    attributes: {
+        rawStorageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'rawStorageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'rawStorageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        storageType: {
+            type: ["s3", "filesystem", "inline", "database"],
+            required: true
+        },
+        storageLocation: {
+            type: "string",
+            required: true
+        },
+        storageKey: {
+            type: "string",
+            required: true
+        },
+        sizeBytes: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'sizeBytes' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'sizeBytes' must be an integer");
+                return true;
+            }
+        },
+        checksumSha256: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 64)
+                    throw new Error("'checksumSha256' must be at least 64 characters");
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'checksumSha256' must be at most 64 characters");
+                return true;
+            }
+        },
+        contentEncoding: {
+            type: ["none", "gzip", "zstd"],
+            required: true
+        },
+        storedAt: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'storedAt' must be an integer");
+                return true;
+            }
+        },
+        expiresAt: {
+            type: "number",
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'expiresAt' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["rawStorageId"]
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        RawMessageStorage: {
+            pk: {
+                field: "pk",
+                composite: ["rawStorageId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "rawMessageStorage",
+        service: "remit",
+        version: "1"
+    }
+};
+export const BodyPartStorage = {
+    attributes: {
+        bodyPartStorageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'bodyPartStorageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'bodyPartStorageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        bodyPartId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'bodyPartId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'bodyPartId' must be at most 25 characters");
+                return true;
+            }
+        },
+        storageType: {
+            type: ["s3", "filesystem", "inline", "database"],
+            required: true
+        },
+        storageLocation: {
+            type: "string",
+            required: true
+        },
+        storageKey: {
+            type: "string",
+            required: true
+        },
+        decodedSizeBytes: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'decodedSizeBytes' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'decodedSizeBytes' must be an integer");
+                return true;
+            }
+        },
+        checksumSha256: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 64)
+                    throw new Error("'checksumSha256' must be at least 64 characters");
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'checksumSha256' must be at most 64 characters");
+                return true;
+            }
+        },
+        contentEncoding: {
+            type: ["none", "gzip", "zstd"],
+            required: true
+        },
+        isDeduped: {
+            type: "boolean",
+            required: true
+        },
+        dedupHash: {
+            type: "string",
+            required: false
+        },
+        storedAt: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'storedAt' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["bodyPartStorageId"]
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        BodyPartStorage: {
+            pk: {
+                field: "pk",
+                composite: ["bodyPartStorageId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "bodyPartStorage",
+        service: "remit",
+        version: "1"
+    }
+};
+export const BodyPartContent = {
+    attributes: {
+        bodyPartContentId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'bodyPartContentId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'bodyPartContentId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        bodyPartId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'bodyPartId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'bodyPartId' must be at most 25 characters");
+                return true;
+            }
+        },
+        content: {
+            type: "string",
+            required: true
+        },
+        contentLength: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && value < 0)
+                    throw new Error("'contentLength' must be at least 0");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'contentLength' must be an integer");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["bodyPartContentId"]
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        BodyPartContent: {
+            pk: {
+                field: "pk",
+                composite: ["bodyPartContentId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "bodyPartContent",
+        service: "remit",
+        version: "1"
+    }
+};
+export const Label = {
+    attributes: {
+        labelId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'labelId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'labelId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        name: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 140)
+                    throw new Error("'name' must be at most 140 characters");
+                return true;
+            }
+        },
+        normalizedName: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 140)
+                    throw new Error("'normalizedName' must be at most 140 characters");
+                return true;
+            }
+        },
+        color: {
+            type: ["Default", "Red", "Orange", "Yellow", "Green", "Teal", "Blue", "Purple", "Gray"],
+            required: true,
+            default: "Default"
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byNormalizedName: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["normalizedName"]
+            },
+            index: "gsi0"
+        },
+        Label: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "sk",
+                composite: ["labelId"]
+            }
+        }
+    },
+    model: {
+        entity: "label",
+        service: "remit",
+        version: "1"
+    }
+};
+export const MessageLabel = {
+    attributes: {
+        messageLabelId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageLabelId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageLabelId' must be at most 25 characters");
+                return true;
+            }
+        },
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        labelId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'labelId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'labelId' must be at most 25 characters");
+                return true;
+            }
+        },
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        appliedByFilterId: {
+            type: "string",
+            required: false,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'appliedByFilterId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'appliedByFilterId' must be at most 25 characters");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byLabelId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: ["labelId", "createdAt"]
+            },
+            index: "gsi2"
+        },
+        byMessageId: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["labelId"]
+            },
+            index: "gsi1"
+        },
+        MessageLabel: {
+            pk: {
+                field: "pk",
+                composite: ["messageLabelId"]
+            },
+            sk: {
+                field: "sk",
+                composite: []
+            }
+        }
+    },
+    model: {
+        entity: "messageLabel",
+        service: "remit",
+        version: "1"
+    }
+};
+export const FilterAnchor = {
+    attributes: {
+        accountConfigId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'accountConfigId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'accountConfigId' must be at most 25 characters");
+                return true;
+            }
+        },
+        filterId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'filterId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'filterId' must be at most 25 characters");
+                return true;
+            }
+        },
+        anchorEmbedding: {
+            type: "list",
+            items: {
+                type: "number"
+            },
+            required: true
+        },
+        anchorEmbeddingId: {
+            type: "string",
+            required: true
+        },
+        anchorSourceText: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 512)
+                    throw new Error("'anchorSourceText' must be at most 512 characters");
+                return true;
+            }
+        },
+        anchorMessageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'anchorMessageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'anchorMessageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        FilterAnchor: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "sk",
+                composite: ["filterId"]
+            }
+        }
+    },
+    model: {
+        entity: "filterAnchor",
+        service: "remit",
+        version: "1"
+    }
+};