@remit/electrodb-entities 0.0.19 → 0.0.20

package/index.mjs

@@ -1381,167 +1381,264 @@ export const OrganizeJobRequest = {
         version: "1"
     }
 };
-export const ThreadMessage = {
+export const CalendarCollection = {
     attributes: {
-        threadMessageId: {
+        calendarId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'threadMessageId' must be at least 25 characters");
+                    throw new Error("'calendarId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'threadMessageId' must be at most 25 characters");
+                    throw new Error("'calendarId' must be at most 25 characters");
                 return true;
             }
         },
-        threadId: {
+        accountConfigId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'threadId' must be at least 25 characters");
+                    throw new Error("'accountConfigId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'threadId' must be at most 25 characters");
+                    throw new Error("'accountConfigId' must be at most 25 characters");
                 return true;
             }
         },
-        messageId: {
+        urlSegment: {
             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");
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'urlSegment' must be at most 64 characters");
                 return true;
             }
         },
-        accountConfigId: {
+        displayName: {
             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");
+                if (typeof value === "string" && value.length > 140)
+                    throw new Error("'displayName' must be at most 140 characters");
                 return true;
             }
         },
-        mailboxId: {
+        color: {
+            type: ["Cal1", "Cal2", "Cal3", "Cal4", "Cal5", "Cal6"],
+            required: true,
+            default: "Cal1"
+        },
+        componentSet: {
+            type: ["VeventOnly"],
+            required: true,
+            default: "VeventOnly"
+        },
+        source: {
+            type: ["Default", "UserCreated", "MailDerived"],
+            required: true,
+            default: "UserCreated"
+        },
+        timezone: {
             type: "string",
             required: true,
+            default: "",
             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");
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'timezone' must be at most 64 characters");
                 return true;
             }
         },
-        uid: {
+        syncSequence: {
             type: "number",
             required: true,
+            default: 0,
             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");
+                    throw new Error("'syncSequence' must be an integer");
                 return true;
             }
         },
-        messageIdHeader: {
-            type: "string",
-            required: false
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
         },
-        inReplyTo: {
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        byUrlSegment: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["urlSegment"]
+            },
+            index: "gsi0"
+        },
+        Calendar: {
+            pk: {
+                field: "pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "sk",
+                composite: ["calendarId"]
+            }
+        }
+    },
+    model: {
+        entity: "calendar",
+        service: "remit",
+        version: "1"
+    }
+};
+export const CalendarObject = {
+    attributes: {
+        calendarObjectId: {
             type: "string",
-            required: false
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'calendarObjectId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'calendarObjectId' must be at most 25 characters");
+                return true;
+            }
         },
-        referenceOrder: {
-            type: "number",
+        calendarId: {
+            type: "string",
             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");
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'calendarId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'calendarId' must be at most 25 characters");
                 return true;
             }
         },
-        fromEmail: {
+        resourceName: {
             type: "string",
-            required: false
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 256)
+                    throw new Error("'resourceName' must be at most 256 characters");
+                return true;
+            }
         },
-        fromName: {
+        icalUid: {
             type: "string",
-            required: false
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 512)
+                    throw new Error("'icalUid' must be at most 512 characters");
+                return true;
+            }
         },
-        subject: {
+        icalData: {
             type: "string",
-            required: false
+            required: true
         },
-        listId: {
+        etag: {
             type: "string",
-            required: false,
+            required: true,
             validate: value => {
-                if (typeof value === "string" && value.length > 256)
-                    throw new Error("'listId' must be at most 256 characters");
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'etag' must be at most 64 characters");
                 return true;
             }
         },
-        internalDate: {
+        sequence: {
             type: "number",
             required: true,
+            default: 0,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'internalDate' must be an integer");
+                    throw new Error("'sequence' must be an integer");
                 return true;
             }
         },
-        sentDate: {
+        syncSequence: {
             type: "number",
             required: true,
+            default: 0,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'sentDate' must be an integer");
+                    throw new Error("'syncSequence' must be an integer");
                 return true;
             }
         },
-        isRead: {
-            type: "boolean",
-            required: true
+        summary: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 512)
+                    throw new Error("'summary' must be at most 512 characters");
+                return true;
+            }
         },
-        hasAttachment: {
-            type: "boolean",
-            required: true
+        dtStart: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'dtStart' must be at most 64 characters");
+                return 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"],
+        dtEnd: {
+            type: "string",
             required: true,
-            default: "none"
+            validate: value => {
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'dtEnd' must be at most 64 characters");
+                return true;
+            }
         },
-        hasStars: {
+        allDay: {
             type: "boolean",
-            required: true
+            required: true,
+            default: false
         },
-        isDeleted: {
+        zoneCertainty: {
+            type: ["Local", "Explicit", "Ambiguous"],
+            required: true,
+            default: "Explicit"
+        },
+        status: {
+            type: ["Confirmed", "Tentative", "Cancelled"],
+            required: true,
+            default: "Confirmed"
+        },
+        transparency: {
+            type: ["Opaque", "Transparent"],
+            required: true,
+            default: "Opaque"
+        },
+        hasRecurrence: {
             type: "boolean",
-            required: true
+            required: true,
+            default: false
         },
-        snippet: {
+        expandedThrough: {
             type: "string",
-            required: false,
+            required: true,
+            default: "",
             validate: value => {
-                if (typeof value === "string" && value.length > 256)
-                    throw new Error("'snippet' must be at most 256 characters");
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'expandedThrough' must be at most 64 characters");
                 return true;
             }
         },
-        category: {
-            type: ["uncategorized", "personal", "newsletter", "marketing", "automated", "transactional", "social"],
-            required: true,
-            default: "uncategorized"
-        },
         createdAt: {
             type: "number",
             readOnly: true,
@@ -1558,18 +1655,234 @@ export const ThreadMessage = {
         }
     },
     indexes: {
-        byMailboxAndReadStatus: {
+        bySyncSequence: {
             pk: {
-                field: "pk",
-                composite: ["accountConfigId"]
+                field: "gsi1pk",
+                composite: ["calendarId"]
             },
             sk: {
-                field: "lsi5sk",
-                composite: ["mailboxId", "isRead", "sentDate"]
+                field: "gsi1sk",
+                composite: ["syncSequence"]
             },
-            index: "lsi5"
+            index: "gsi1"
         },
-        byStarred: {
+        byUid: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["calendarId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["icalUid"]
+            },
+            index: "gsi0"
+        },
+        CalendarObject: {
+            pk: {
+                field: "pk",
+                composite: ["calendarId"]
+            },
+            sk: {
+                field: "sk",
+                composite: ["calendarObjectId"]
+            }
+        }
+    },
+    model: {
+        entity: "calendarObject",
+        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
+        },
+        listId: {
+            type: "string",
+            required: false,
+            validate: value => {
+                if (typeof value === "string" && value.length > 256)
+                    throw new Error("'listId' must be at most 256 characters");
+                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;
+            }
+        },
+        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"]
@@ -2668,510 +2981,22 @@ export const Message = {
         },
         placementDecidedAt: {
             type: "number",
-            required: false,
-            validate: value => {
-                if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'placementDecidedAt' must be an integer");
-                return true;
-            }
-        },
-        spamReport: {
-            type: "map",
-            properties: {
-                reportedAt: {
-                    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 ConfigImport = {
-    attributes: {
-        importId: {
-            type: "string",
-            required: true,
-            validate: value => {
-                if (typeof value === "string" && value.length < 25)
-                    throw new Error("'importId' must be at least 25 characters");
-                if (typeof value === "string" && value.length > 25)
-                    throw new Error("'importId' 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;
-            }
-        },
-        schemaVersion: {
-            type: "number",
-            required: true,
-            validate: value => {
-                if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'schemaVersion' must be an integer");
-                return true;
-            }
-        },
-        state: {
-            type: ["Pending", "Complete"],
-            required: true,
-            default: "Pending"
-        },
-        document: {
-            type: CustomAttributeType("any"),
-            required: true
+            required: false,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'placementDecidedAt' must be an integer");
+                return true;
+            }
         },
-        unresolvedRefs: {
-            type: "list",
-            items: {
-                type: "map",
-                properties: {
-                    kind: {
-                        type: ["FolderRole", "MailboxOverride", "FilterAction"],
-                        required: true
-                    },
-                    accountId: {
-                        type: "string",
-                        required: true
-                    },
-                    folderPath: {
-                        type: "string",
-                        required: true
-                    },
-                    target: {
-                        type: "string",
-                        required: true
-                    }
+        spamReport: {
+            type: "map",
+            properties: {
+                reportedAt: {
+                    type: "number",
+                    required: true
                 }
             },
-            required: true
+            required: false
         },
         createdAt: {
             type: "number",
@@ -3180,16 +3005,6 @@ export const ConfigImport = {
             default: () => Date.now(),
             set: () => Date.now()
         },
-        completedAt: {
-            type: "number",
-            required: true,
-            default: 0,
-            validate: value => {
-                if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'completedAt' must be an integer");
-                return true;
-            }
-        },
         updatedAt: {
             type: "number",
             watch: "*",
@@ -3199,21 +3014,34 @@ export const ConfigImport = {
         }
     },
     indexes: {
-        byAccountConfigId: {
+        byMessageId: {
+            pk: {
+                field: "gsi2pk",
+                composite: ["messageId"]
+            },
+            sk: {
+                field: "gsi2sk",
+                composite: []
+            },
+            index: "gsi2",
+            collection: "messageData"
+        },
+        byMailboxId: {
             pk: {
                 field: "gsi0pk",
-                composite: ["accountConfigId"]
+                composite: ["mailboxId"]
             },
             sk: {
                 field: "gsi0sk",
-                composite: ["createdAt"]
+                composite: ["uid"]
             },
-            index: "gsi0"
+            index: "gsi0",
+            collection: "message"
         },
-        ConfigImport: {
+        Message: {
             pk: {
                 field: "pk",
-                composite: ["importId"]
+                composite: ["messageId"]
             },
             sk: {
                 field: "sk",
@@ -3222,43 +3050,128 @@ export const ConfigImport = {
         }
     },
     model: {
-        entity: "configImport",
+        entity: "message",
         service: "remit",
         version: "1"
     }
 };
-export const AccountSetting = {
+export const BodyPart = {
     attributes: {
-        accountSettingId: {
+        bodyPartId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'accountSettingId' must be at least 25 characters");
+                    throw new Error("'bodyPartId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'accountSettingId' must be at most 25 characters");
+                    throw new Error("'bodyPartId' must be at most 25 characters");
                 return true;
             }
         },
-        accountConfigId: {
+        messageId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'accountConfigId' must be at least 25 characters");
+                    throw new Error("'messageId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'accountConfigId' must be at most 25 characters");
+                    throw new Error("'messageId' must be at most 25 characters");
                 return true;
             }
         },
-        name: {
+        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
         },
-        value: {
-            type: CustomAttributeType("any"),
+        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,
@@ -3275,21 +3188,22 @@ export const AccountSetting = {
         }
     },
     indexes: {
-        byAccountConfigId: {
+        byMessageId: {
             pk: {
-                field: "gsi0pk",
-                composite: ["accountConfigId"]
+                field: "gsi2pk",
+                composite: ["messageId"]
             },
             sk: {
-                field: "gsi0sk",
-                composite: ["name"]
+                field: "gsi2sk",
+                composite: ["bodyPartId"]
             },
-            index: "gsi0"
+            index: "gsi2",
+            collection: "messageData"
         },
-        AccountSetting: {
+        BodyPart: {
             pk: {
                 field: "pk",
-                composite: ["accountSettingId"]
+                composite: ["bodyPartId"]
             },
             sk: {
                 field: "sk",
@@ -3298,57 +3212,97 @@ export const AccountSetting = {
         }
     },
     model: {
-        entity: "accountSetting",
+        entity: "bodyPart",
         service: "remit",
         version: "1"
     }
 };
-export const MailboxAttributeEntry = {
+export const MessageReference = {
     attributes: {
-        mailboxAttributeId: {
+        messageReferenceId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'mailboxAttributeId' must be at least 25 characters");
+                    throw new Error("'messageReferenceId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'mailboxAttributeId' must be at most 25 characters");
+                    throw new Error("'messageReferenceId' must be at most 25 characters");
                 return true;
             }
         },
-        mailboxId: {
+        messageId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'mailboxId' must be at least 25 characters");
+                    throw new Error("'messageId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'mailboxId' must be at most 25 characters");
+                    throw new Error("'messageId' must be at most 25 characters");
                 return true;
             }
         },
-        attributeName: {
-            type: ["\NonExistent", "\Noinferiors", "\Noselect", "\HasChildren", "\HasNoChildren", "\Marked", "\Unmarked", "\Subscribed", "\Remote"],
+        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: {
-        byMailboxId: {
+        byMessageId: {
             pk: {
-                field: "gsi1pk",
-                composite: ["mailboxId"]
+                field: "gsi2pk",
+                composite: ["messageId"]
             },
             sk: {
-                field: "gsi1sk",
-                composite: ["mailboxAttributeId"]
+                field: "gsi2sk",
+                composite: ["messageReferenceId"]
             },
-            index: "gsi1",
-            collection: "mailbox"
+            index: "gsi2",
+            collection: "messageData"
         },
-        MailboxAttributeEntry: {
+        MessageReference: {
             pk: {
                 field: "pk",
-                composite: ["mailboxAttributeId"]
+                composite: ["messageReferenceId"]
             },
             sk: {
                 field: "sk",
@@ -3357,120 +3311,101 @@ export const MailboxAttributeEntry = {
         }
     },
     model: {
-        entity: "mailboxAttributeEntry",
+        entity: "messageReference",
         service: "remit",
         version: "1"
     }
 };
-export const MailboxSpecialUseEntry = {
+export const EnvelopeAddress = {
     attributes: {
-        mailboxSpecialUseId: {
+        envelopeAddressId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'mailboxSpecialUseId' must be at least 25 characters");
+                    throw new Error("'envelopeAddressId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'mailboxSpecialUseId' must be at most 25 characters");
+                    throw new Error("'envelopeAddressId' must be at most 25 characters");
                 return true;
             }
         },
-        mailboxId: {
+        messageId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'mailboxId' must be at least 25 characters");
+                    throw new Error("'messageId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'mailboxId' must be at most 25 characters");
+                    throw new Error("'messageId' 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: {
+        addressId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'mailboxFlagId' must be at least 25 characters");
+                    throw new Error("'addressId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'mailboxFlagId' must be at most 25 characters");
+                    throw new Error("'addressId' must be at most 25 characters");
                 return true;
             }
         },
-        mailboxId: {
+        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 === "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");
+                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;
             }
         },
-        flagName: {
-            type: CustomAttributeType("any"),
-            required: true
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
         },
-        isPermanent: {
-            type: "boolean",
-            required: true
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
         }
     },
     indexes: {
-        byMailboxId: {
+        byMessageId: {
             pk: {
-                field: "gsi1pk",
-                composite: ["mailboxId"]
+                field: "gsi2pk",
+                composite: ["messageId"]
             },
             sk: {
-                field: "gsi1sk",
-                composite: ["mailboxFlagId"]
+                field: "gsi2sk",
+                composite: ["envelopeAddressId"]
             },
-            index: "gsi1",
-            collection: "mailbox"
+            index: "gsi2",
+            collection: "messageData"
         },
-        MailboxFlag: {
+        EnvelopeAddress: {
             pk: {
                 field: "pk",
-                composite: ["mailboxFlagId"]
+                composite: ["envelopeAddressId"]
             },
             sk: {
                 field: "sk",
@@ -3479,150 +3414,163 @@ export const MailboxFlag = {
         }
     },
     model: {
-        entity: "mailboxFlag",
+        entity: "envelopeAddress",
         service: "remit",
         version: "1"
     }
 };
-export const MailboxLock = {
+export const ConfigImport = {
     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: {
+        importId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'accountId' must be at least 25 characters");
+                    throw new Error("'importId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'accountId' must be at most 25 characters");
+                    throw new Error("'importId' must be at most 25 characters");
                 return true;
             }
         },
-        lockId: {
+        accountConfigId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'lockId' must be at least 25 characters");
+                    throw new Error("'accountConfigId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'lockId' must be at most 25 characters");
+                    throw new Error("'accountConfigId' must be at most 25 characters");
                 return true;
             }
         },
-        acquiredAt: {
+        schemaVersion: {
             type: "number",
             required: true,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'acquiredAt' must be an integer");
+                    throw new Error("'schemaVersion' must be an integer");
                 return true;
             }
         },
-        lockedBy: {
-            type: "string",
+        state: {
+            type: ["Pending", "Complete"],
+            required: true,
+            default: "Pending"
+        },
+        document: {
+            type: CustomAttributeType("any"),
             required: true
         },
-        ttl: {
+        unresolvedRefs: {
+            type: "list",
+            items: {
+                type: "map",
+                properties: {
+                    kind: {
+                        type: ["FolderRole", "MailboxOverride", "FilterAction"],
+                        required: true
+                    },
+                    accountId: {
+                        type: "string",
+                        required: true
+                    },
+                    folderPath: {
+                        type: "string",
+                        required: true
+                    },
+                    target: {
+                        type: "string",
+                        required: true
+                    }
+                }
+            },
+            required: true
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        completedAt: {
             type: "number",
             required: true,
+            default: 0,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'ttl' must be an integer");
+                    throw new Error("'completedAt' must be an integer");
                 return true;
             }
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
         }
     },
     indexes: {
-        allLocks: {
-            pk: {
-                field: "gsi2pk",
-                composite: []
-            },
-            sk: {
-                field: "gsi2sk",
-                composite: ["acquiredAt"]
-            },
-            index: "gsi2",
-            collection: "locks"
-        },
-        byAccountId: {
+        byAccountConfigId: {
             pk: {
-                field: "gsi1pk",
-                composite: ["accountId"]
+                field: "gsi0pk",
+                composite: ["accountConfigId"]
             },
             sk: {
-                field: "gsi1sk",
-                composite: ["mailboxId", "eventName"]
+                field: "gsi0sk",
+                composite: ["createdAt"]
             },
-            index: "gsi1"
+            index: "gsi0"
         },
-        MailboxLock: {
+        ConfigImport: {
             pk: {
                 field: "pk",
-                composite: ["mailboxId"]
+                composite: ["importId"]
             },
             sk: {
                 field: "sk",
-                composite: ["eventName"]
+                composite: []
             }
         }
     },
     model: {
-        entity: "mailboxLock",
+        entity: "configImport",
         service: "remit",
         version: "1"
     }
 };
-export const MessageFlag = {
+export const AccountSetting = {
     attributes: {
-        messageFlagId: {
+        accountSettingId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'messageFlagId' must be at least 25 characters");
+                    throw new Error("'accountSettingId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'messageFlagId' must be at most 25 characters");
+                    throw new Error("'accountSettingId' must be at most 25 characters");
                 return true;
             }
         },
-        messageId: {
+        accountConfigId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'messageId' must be at least 25 characters");
+                    throw new Error("'accountConfigId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'messageId' must be at most 25 characters");
+                    throw new Error("'accountConfigId' must be at most 25 characters");
                 return true;
             }
         },
-        flagName: {
-            type: CustomAttributeType("any"),
+        name: {
+            type: "string",
             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;
-            }
+        value: {
+            type: CustomAttributeType("any"),
+            required: true
         },
         createdAt: {
             type: "number",
@@ -3640,22 +3588,21 @@ export const MessageFlag = {
         }
     },
     indexes: {
-        byMessageId: {
+        byAccountConfigId: {
             pk: {
-                field: "gsi2pk",
-                composite: ["messageId"]
+                field: "gsi0pk",
+                composite: ["accountConfigId"]
             },
             sk: {
-                field: "gsi2sk",
-                composite: ["messageFlagId"]
+                field: "gsi0sk",
+                composite: ["name"]
             },
-            index: "gsi2",
-            collection: "messageData"
+            index: "gsi0"
         },
-        MessageFlag: {
+        AccountSetting: {
             pk: {
                 field: "pk",
-                composite: ["messageFlagId"]
+                composite: ["accountSettingId"]
             },
             sk: {
                 field: "sk",
@@ -3664,104 +3611,179 @@ export const MessageFlag = {
         }
     },
     model: {
-        entity: "messageFlag",
+        entity: "accountSetting",
         service: "remit",
         version: "1"
     }
 };
-export const MessagePlacementMove = {
+export const MailboxAttributeEntry = {
     attributes: {
-        messageId: {
+        mailboxAttributeId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'messageId' must be at least 25 characters");
+                    throw new Error("'mailboxAttributeId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'messageId' must be at most 25 characters");
+                    throw new Error("'mailboxAttributeId' must be at most 25 characters");
                 return true;
             }
         },
-        accountId: {
+        mailboxId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'accountId' must be at least 25 characters");
+                    throw new Error("'mailboxId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'accountId' must be at most 25 characters");
+                    throw new Error("'mailboxId' must be at most 25 characters");
                 return true;
             }
         },
-        accountConfigId: {
+        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("'accountConfigId' must be at least 25 characters");
+                    throw new Error("'mailboxSpecialUseId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'accountConfigId' must be at most 25 characters");
+                    throw new Error("'mailboxSpecialUseId' must be at most 25 characters");
                 return true;
             }
         },
-        sourceMailboxId: {
+        mailboxId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'sourceMailboxId' must be at least 25 characters");
+                    throw new Error("'mailboxId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'sourceMailboxId' must be at most 25 characters");
+                    throw new Error("'mailboxId' must be at most 25 characters");
                 return true;
             }
         },
-        destinationMailboxId: {
+        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("'destinationMailboxId' must be at least 25 characters");
+                    throw new Error("'mailboxFlagId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'destinationMailboxId' must be at most 25 characters");
+                    throw new Error("'mailboxFlagId' must be at most 25 characters");
                 return true;
             }
         },
-        state: {
-            type: ["pending", "queued", "processing", "processed"],
+        mailboxId: {
+            type: "string",
             required: true,
-            default: "pending"
+            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;
+            }
         },
-        createdAt: {
-            type: "number",
-            readOnly: true,
-            required: true,
-            default: () => Date.now(),
-            set: () => Date.now()
+        flagName: {
+            type: CustomAttributeType("any"),
+            required: true
         },
-        updatedAt: {
-            type: "number",
-            watch: "*",
-            required: true,
-            default: () => Date.now(),
-            set: () => Date.now()
+        isPermanent: {
+            type: "boolean",
+            required: true
         }
     },
     indexes: {
-        byAccountId: {
+        byMailboxId: {
             pk: {
-                field: "gsi0pk",
-                composite: ["accountId"]
+                field: "gsi1pk",
+                composite: ["mailboxId"]
             },
             sk: {
-                field: "gsi0sk",
-                composite: ["messageId"]
+                field: "gsi1sk",
+                composite: ["mailboxFlagId"]
             },
-            index: "gsi0"
+            index: "gsi1",
+            collection: "mailbox"
         },
-        MessagePlacementMove: {
+        MailboxFlag: {
             pk: {
                 field: "pk",
-                composite: ["messageId"]
+                composite: ["mailboxFlagId"]
             },
             sk: {
                 field: "sk",
@@ -3770,25 +3792,25 @@ export const MessagePlacementMove = {
         }
     },
     model: {
-        entity: "messagePlacementMove",
+        entity: "mailboxFlag",
         service: "remit",
         version: "1"
     }
 };
-export const MessageFlagPush = {
+export const MailboxLock = {
     attributes: {
-        messageId: {
+        mailboxId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'messageId' must be at least 25 characters");
+                    throw new Error("'mailboxId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'messageId' must be at most 25 characters");
+                    throw new Error("'mailboxId' must be at most 25 characters");
                 return true;
             }
         },
-        flagName: {
+        eventName: {
             type: "string",
             required: true
         },
@@ -3803,102 +3825,91 @@ export const MessageFlagPush = {
                 return true;
             }
         },
-        accountConfigId: {
+        lockId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'accountConfigId' must be at least 25 characters");
+                    throw new Error("'lockId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'accountConfigId' must be at most 25 characters");
+                    throw new Error("'lockId' must be at most 25 characters");
                 return true;
             }
         },
-        mailboxId: {
-            type: "string",
+        acquiredAt: {
+            type: "number",
             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");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'acquiredAt' must be an integer");
                 return true;
             }
         },
-        operation: {
-            type: ["add", "remove"],
+        lockedBy: {
+            type: "string",
             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: {
+        ttl: {
             type: "number",
-            watch: "*",
             required: true,
-            default: () => Date.now(),
-            set: () => Date.now()
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'ttl' must be an integer");
+                return true;
+            }
         }
     },
     indexes: {
-        byMailboxId: {
+        allLocks: {
             pk: {
-                field: "gsi1pk",
-                composite: ["mailboxId"]
+                field: "gsi2pk",
+                composite: []
             },
             sk: {
-                field: "gsi1sk",
-                composite: ["messageId", "flagName"]
+                field: "gsi2sk",
+                composite: ["acquiredAt"]
             },
-            index: "gsi1"
+            index: "gsi2",
+            collection: "locks"
         },
         byAccountId: {
             pk: {
-                field: "gsi0pk",
+                field: "gsi1pk",
                 composite: ["accountId"]
             },
             sk: {
-                field: "gsi0sk",
-                composite: ["messageId", "flagName"]
+                field: "gsi1sk",
+                composite: ["mailboxId", "eventName"]
             },
-            index: "gsi0"
+            index: "gsi1"
         },
-        MessageFlagPush: {
+        MailboxLock: {
             pk: {
                 field: "pk",
-                composite: ["messageId"]
+                composite: ["mailboxId"]
             },
             sk: {
                 field: "sk",
-                composite: ["flagName"]
+                composite: ["eventName"]
             }
         }
     },
     model: {
-        entity: "messageFlagPush",
+        entity: "mailboxLock",
         service: "remit",
         version: "1"
     }
 };
-export const Envelope = {
+export const MessageFlag = {
     attributes: {
-        envelopeId: {
+        messageFlagId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'envelopeId' must be at least 25 characters");
+                    throw new Error("'messageFlagId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'envelopeId' must be at most 25 characters");
+                    throw new Error("'messageFlagId' must be at most 25 characters");
                 return true;
             }
         },
@@ -3913,27 +3924,19 @@ export const Envelope = {
                 return true;
             }
         },
-        dateValue: {
+        flagName: {
+            type: CustomAttributeType("any"),
+            required: true
+        },
+        setAt: {
             type: "number",
             required: true,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'dateValue' must be an integer");
+                    throw new Error("'setAt' 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,
@@ -3957,15 +3960,15 @@ export const Envelope = {
             },
             sk: {
                 field: "gsi2sk",
-                composite: ["envelopeId"]
+                composite: ["messageFlagId"]
             },
             index: "gsi2",
             collection: "messageData"
         },
-        Envelope: {
+        MessageFlag: {
             pk: {
                 field: "pk",
-                composite: ["envelopeId"]
+                composite: ["messageFlagId"]
             },
             sk: {
                 field: "sk",
@@ -3974,79 +3977,72 @@ export const Envelope = {
         }
     },
     model: {
-        entity: "envelope",
+        entity: "messageFlag",
         service: "remit",
         version: "1"
     }
 };
-export const SenderSignerStanding = {
+export const MessagePlacementMove = {
     attributes: {
-        accountConfigId: {
+        messageId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'accountConfigId' must be at least 25 characters");
+                    throw new Error("'messageId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'accountConfigId' must be at most 25 characters");
+                    throw new Error("'messageId' must be at most 25 characters");
                 return true;
             }
         },
-        senderKey: {
+        accountId: {
             type: "string",
             required: true,
             validate: value => {
-                if (typeof value === "string" && value.length > 256)
-                    throw new Error("'senderKey' must be at most 256 characters");
+                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;
             }
         },
-        signerDomain: {
+        accountConfigId: {
             type: "string",
             required: true,
             validate: value => {
-                if (typeof value === "string" && value.length > 256)
-                    throw new Error("'signerDomain' must be at most 256 characters");
-                return true;
-            }
-        },
-        messageCount: {
-            type: "number",
-            required: true,
-            default: 0,
-            validate: value => {
-                if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'messageCount' must be an integer");
+                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;
             }
         },
-        firstSeenAt: {
-            type: "number",
+        sourceMailboxId: {
+            type: "string",
             required: true,
             validate: value => {
-                if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'firstSeenAt' must be an integer");
+                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;
             }
         },
-        lastSeenAt: {
-            type: "number",
+        destinationMailboxId: {
+            type: "string",
             required: true,
             validate: value => {
-                if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'lastSeenAt' must be an integer");
+                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;
             }
         },
-        userAffirmedAt: {
-            type: "number",
+        state: {
+            type: ["pending", "queued", "processing", "processed"],
             required: true,
-            default: 0,
-            validate: value => {
-                if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'userAffirmedAt' must be an integer");
-                return true;
-            }
+            default: "pending"
         },
         createdAt: {
             type: "number",
@@ -4064,71 +4060,93 @@ export const SenderSignerStanding = {
         }
     },
     indexes: {
-        SenderSignerStanding: {
+        byAccountId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["messageId"]
+            },
+            index: "gsi0"
+        },
+        MessagePlacementMove: {
             pk: {
                 field: "pk",
-                composite: ["accountConfigId"]
+                composite: ["messageId"]
             },
             sk: {
                 field: "sk",
-                composite: ["senderKey", "signerDomain"]
+                composite: []
             }
         }
     },
     model: {
-        entity: "senderSignerStanding",
+        entity: "messagePlacementMove",
         service: "remit",
         version: "1"
     }
 };
-export const BodyPartParameter = {
+export const MessageFlagPush = {
     attributes: {
-        bodyPartParameterId: {
+        messageId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'bodyPartParameterId' must be at least 25 characters");
+                    throw new Error("'messageId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'bodyPartParameterId' must be at most 25 characters");
+                    throw new Error("'messageId' must be at most 25 characters");
                 return true;
             }
         },
-        messageId: {
+        flagName: {
+            type: "string",
+            required: true
+        },
+        accountId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'messageId' must be at least 25 characters");
+                    throw new Error("'accountId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'messageId' must be at most 25 characters");
+                    throw new Error("'accountId' must be at most 25 characters");
                 return true;
             }
         },
-        bodyPartId: {
+        accountConfigId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'bodyPartId' must be at least 25 characters");
+                    throw new Error("'accountConfigId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'bodyPartId' must be at most 25 characters");
+                    throw new Error("'accountConfigId' must be at most 25 characters");
                 return true;
             }
         },
-        parameterName: {
+        mailboxId: {
             type: "string",
             required: true,
             validate: value => {
-                if (typeof value === "string" && value.length < 1)
-                    throw new Error("'parameterName' must be at least 1 characters");
+                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;
             }
         },
-        parameterValue: {
-            type: "string",
+        operation: {
+            type: ["add", "remove"],
             required: true
         },
+        state: {
+            type: ["pending", "queued", "processing", "processed"],
+            required: true,
+            default: "pending"
+        },
         createdAt: {
             type: "number",
             readOnly: true,
@@ -4145,114 +4163,89 @@ export const BodyPartParameter = {
         }
     },
     indexes: {
-        byMessageId: {
+        byMailboxId: {
             pk: {
-                field: "gsi2pk",
-                composite: ["messageId"]
+                field: "gsi1pk",
+                composite: ["mailboxId"]
             },
             sk: {
-                field: "gsi2sk",
-                composite: ["bodyPartParameterId"]
+                field: "gsi1sk",
+                composite: ["messageId", "flagName"]
             },
-            index: "gsi2",
-            collection: "messageData"
+            index: "gsi1"
         },
-        BodyPartParameter: {
+        byAccountId: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["messageId", "flagName"]
+            },
+            index: "gsi0"
+        },
+        MessageFlagPush: {
             pk: {
                 field: "pk",
-                composite: ["bodyPartParameterId"]
+                composite: ["messageId"]
             },
             sk: {
                 field: "sk",
-                composite: []
+                composite: ["flagName"]
             }
         }
     },
     model: {
-        entity: "bodyPartParameter",
+        entity: "messageFlagPush",
         service: "remit",
         version: "1"
     }
 };
-export const RawMessageStorage = {
+export const Envelope = {
     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: {
+        envelopeId: {
             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");
+                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;
             }
         },
-        checksumSha256: {
+        messageId: {
             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");
+                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;
             }
         },
-        contentEncoding: {
-            type: ["none", "gzip", "zstd"],
-            required: true
-        },
-        storedAt: {
+        dateValue: {
             type: "number",
             required: true,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'storedAt' must be an integer");
+                    throw new Error("'dateValue' 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;
-            }
+        dateRaw: {
+            type: "string",
+            required: true
+        },
+        subject: {
+            type: "string",
+            required: false
+        },
+        messageIdValue: {
+            type: "string",
+            required: false
         },
         createdAt: {
             type: "number",
@@ -4277,15 +4270,15 @@ export const RawMessageStorage = {
             },
             sk: {
                 field: "gsi2sk",
-                composite: ["rawStorageId"]
+                composite: ["envelopeId"]
             },
             index: "gsi2",
             collection: "messageData"
         },
-        RawMessageStorage: {
+        Envelope: {
             pk: {
                 field: "pk",
-                composite: ["rawStorageId"]
+                composite: ["envelopeId"]
             },
             sk: {
                 field: "sk",
@@ -4294,98 +4287,77 @@ export const RawMessageStorage = {
         }
     },
     model: {
-        entity: "rawMessageStorage",
+        entity: "envelope",
         service: "remit",
         version: "1"
     }
 };
-export const BodyPartStorage = {
+export const SenderSignerStanding = {
     attributes: {
-        bodyPartStorageId: {
+        accountConfigId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'bodyPartStorageId' must be at least 25 characters");
+                    throw new Error("'accountConfigId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'bodyPartStorageId' must be at most 25 characters");
+                    throw new Error("'accountConfigId' must be at most 25 characters");
                 return true;
             }
         },
-        messageId: {
+        senderKey: {
             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");
+                if (typeof value === "string" && value.length > 256)
+                    throw new Error("'senderKey' must be at most 256 characters");
                 return true;
             }
         },
-        bodyPartId: {
+        signerDomain: {
             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");
+                if (typeof value === "string" && value.length > 256)
+                    throw new Error("'signerDomain' must be at most 256 characters");
                 return true;
             }
         },
-        storageType: {
-            type: ["s3", "filesystem", "inline", "database"],
-            required: true
-        },
-        storageLocation: {
-            type: "string",
-            required: true
-        },
-        storageKey: {
-            type: "string",
-            required: true
-        },
-        decodedSizeBytes: {
+        messageCount: {
             type: "number",
             required: true,
+            default: 0,
             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");
+                    throw new Error("'messageCount' must be an integer");
                 return true;
             }
         },
-        checksumSha256: {
-            type: "string",
+        firstSeenAt: {
+            type: "number",
             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");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'firstSeenAt' must be an integer");
                 return true;
             }
         },
-        contentEncoding: {
-            type: ["none", "gzip", "zstd"],
-            required: true
-        },
-        isDeduped: {
-            type: "boolean",
-            required: true
-        },
-        dedupHash: {
-            type: "string",
-            required: false
+        lastSeenAt: {
+            type: "number",
+            required: true,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'lastSeenAt' must be an integer");
+                return true;
+            }
         },
-        storedAt: {
+        userAffirmedAt: {
             type: "number",
             required: true,
+            default: 0,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'storedAt' must be an integer");
+                    throw new Error("'userAffirmedAt' must be an integer");
                 return true;
             }
         },
@@ -4405,45 +4377,33 @@ export const BodyPartStorage = {
         }
     },
     indexes: {
-        byMessageId: {
-            pk: {
-                field: "gsi2pk",
-                composite: ["messageId"]
-            },
-            sk: {
-                field: "gsi2sk",
-                composite: ["bodyPartStorageId"]
-            },
-            index: "gsi2",
-            collection: "messageData"
-        },
-        BodyPartStorage: {
+        SenderSignerStanding: {
             pk: {
                 field: "pk",
-                composite: ["bodyPartStorageId"]
+                composite: ["accountConfigId"]
             },
             sk: {
                 field: "sk",
-                composite: []
+                composite: ["senderKey", "signerDomain"]
             }
         }
     },
     model: {
-        entity: "bodyPartStorage",
+        entity: "senderSignerStanding",
         service: "remit",
         version: "1"
     }
 };
-export const BodyPartContent = {
+export const BodyPartParameter = {
     attributes: {
-        bodyPartContentId: {
+        bodyPartParameterId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'bodyPartContentId' must be at least 25 characters");
+                    throw new Error("'bodyPartParameterId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'bodyPartContentId' must be at most 25 characters");
+                    throw new Error("'bodyPartParameterId' must be at most 25 characters");
                 return true;
             }
         },
@@ -4469,21 +4429,19 @@ export const BodyPartContent = {
                 return true;
             }
         },
-        content: {
+        parameterName: {
             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");
+                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,
@@ -4507,15 +4465,15 @@ export const BodyPartContent = {
             },
             sk: {
                 field: "gsi2sk",
-                composite: ["bodyPartContentId"]
+                composite: ["bodyPartParameterId"]
             },
             index: "gsi2",
             collection: "messageData"
         },
-        BodyPartContent: {
+        BodyPartParameter: {
             pk: {
                 field: "pk",
-                composite: ["bodyPartContentId"]
+                composite: ["bodyPartParameterId"]
             },
             sk: {
                 field: "sk",
@@ -4524,85 +4482,88 @@ export const BodyPartContent = {
         }
     },
     model: {
-        entity: "bodyPartContent",
+        entity: "bodyPartParameter",
         service: "remit",
         version: "1"
     }
 };
-export const CalendarCollection = {
+export const RawMessageStorage = {
     attributes: {
-        calendarId: {
+        rawStorageId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'calendarId' must be at least 25 characters");
+                    throw new Error("'rawStorageId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'calendarId' must be at most 25 characters");
+                    throw new Error("'rawStorageId' must be at most 25 characters");
                 return true;
             }
         },
-        accountConfigId: {
+        messageId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'accountConfigId' must be at least 25 characters");
+                    throw new Error("'messageId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'accountConfigId' must be at most 25 characters");
+                    throw new Error("'messageId' must be at most 25 characters");
                 return true;
             }
         },
-        urlSegment: {
+        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 === "string" && value.length > 64)
-                    throw new Error("'urlSegment' must be at most 64 characters");
+                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;
             }
         },
-        displayName: {
+        checksumSha256: {
             type: "string",
             required: true,
             validate: value => {
-                if (typeof value === "string" && value.length > 140)
-                    throw new Error("'displayName' must be at most 140 characters");
+                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;
             }
         },
-        color: {
-            type: ["Cal1", "Cal2", "Cal3", "Cal4", "Cal5", "Cal6"],
-            required: true,
-            default: "Cal1"
-        },
-        componentSet: {
-            type: ["VeventOnly"],
-            required: true,
-            default: "VeventOnly"
-        },
-        source: {
-            type: ["Default", "UserCreated", "MailDerived"],
-            required: true,
-            default: "UserCreated"
+        contentEncoding: {
+            type: ["none", "gzip", "zstd"],
+            required: true
         },
-        timezone: {
-            type: "string",
+        storedAt: {
+            type: "number",
             required: true,
-            default: "",
             validate: value => {
-                if (typeof value === "string" && value.length > 64)
-                    throw new Error("'timezone' must be at most 64 characters");
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'storedAt' must be an integer");
                 return true;
             }
         },
-        syncSequence: {
+        expiresAt: {
             type: "number",
-            required: true,
-            default: 0,
+            required: false,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'syncSequence' must be an integer");
+                    throw new Error("'expiresAt' must be an integer");
                 return true;
             }
         },
@@ -4622,168 +4583,217 @@ export const CalendarCollection = {
         }
     },
     indexes: {
-        byUrlSegment: {
+        byMessageId: {
             pk: {
-                field: "gsi0pk",
-                composite: ["accountConfigId"]
+                field: "gsi2pk",
+                composite: ["messageId"]
             },
             sk: {
-                field: "gsi0sk",
-                composite: ["urlSegment"]
+                field: "gsi2sk",
+                composite: ["rawStorageId"]
             },
-            index: "gsi0"
+            index: "gsi2",
+            collection: "messageData"
         },
-        Calendar: {
+        RawMessageStorage: {
             pk: {
                 field: "pk",
-                composite: ["accountConfigId"]
+                composite: ["rawStorageId"]
             },
             sk: {
                 field: "sk",
-                composite: ["calendarId"]
+                composite: []
             }
         }
     },
     model: {
-        entity: "calendar",
+        entity: "rawMessageStorage",
         service: "remit",
         version: "1"
     }
 };
-export const CalendarObject = {
+export const BodyPartStorage = {
     attributes: {
-        calendarObjectId: {
+        bodyPartStorageId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'calendarObjectId' must be at least 25 characters");
+                    throw new Error("'bodyPartStorageId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'calendarObjectId' must be at most 25 characters");
+                    throw new Error("'bodyPartStorageId' must be at most 25 characters");
                 return true;
             }
         },
-        calendarId: {
+        messageId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'calendarId' must be at least 25 characters");
+                    throw new Error("'messageId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'calendarId' must be at most 25 characters");
+                    throw new Error("'messageId' must be at most 25 characters");
                 return true;
             }
         },
-        resourceName: {
+        bodyPartId: {
             type: "string",
             required: true,
             validate: value => {
-                if (typeof value === "string" && value.length > 256)
-                    throw new Error("'resourceName' must be at most 256 characters");
+                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;
             }
         },
-        icalUid: {
+        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 === "string" && value.length > 512)
-                    throw new Error("'icalUid' must be at most 512 characters");
+                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;
             }
         },
-        icalData: {
-            type: "string",
-            required: true
-        },
-        etag: {
+        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("'etag' must be at most 64 characters");
+                    throw new Error("'checksumSha256' must be at most 64 characters");
                 return true;
             }
         },
-        sequence: {
+        contentEncoding: {
+            type: ["none", "gzip", "zstd"],
+            required: true
+        },
+        isDeduped: {
+            type: "boolean",
+            required: true
+        },
+        dedupHash: {
+            type: "string",
+            required: false
+        },
+        storedAt: {
             type: "number",
             required: true,
-            default: 0,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'sequence' must be an integer");
+                    throw new Error("'storedAt' must be an integer");
                 return true;
             }
         },
-        syncSequence: {
+        createdAt: {
             type: "number",
+            readOnly: true,
             required: true,
-            default: 0,
-            validate: value => {
-                if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'syncSequence' must be an integer");
-                return true;
-            }
+            default: () => Date.now(),
+            set: () => Date.now()
         },
-        summary: {
+        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 > 512)
-                    throw new Error("'summary' must be at most 512 characters");
+                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;
             }
         },
-        dtStart: {
+        messageId: {
             type: "string",
             required: true,
             validate: value => {
-                if (typeof value === "string" && value.length > 64)
-                    throw new Error("'dtStart' must be at most 64 characters");
+                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;
             }
         },
-        dtEnd: {
+        bodyPartId: {
             type: "string",
             required: true,
             validate: value => {
-                if (typeof value === "string" && value.length > 64)
-                    throw new Error("'dtEnd' must be at most 64 characters");
+                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;
             }
         },
-        allDay: {
-            type: "boolean",
-            required: true,
-            default: false
-        },
-        zoneCertainty: {
-            type: ["Local", "Explicit", "Ambiguous"],
-            required: true,
-            default: "Explicit"
-        },
-        status: {
-            type: ["Confirmed", "Tentative", "Cancelled"],
-            required: true,
-            default: "Confirmed"
-        },
-        transparency: {
-            type: ["Opaque", "Transparent"],
-            required: true,
-            default: "Opaque"
-        },
-        hasRecurrence: {
-            type: "boolean",
-            required: true,
-            default: false
-        },
-        expandedThrough: {
+        content: {
             type: "string",
+            required: true
+        },
+        contentLength: {
+            type: "number",
             required: true,
-            default: "",
             validate: value => {
-                if (typeof value === "string" && value.length > 64)
-                    throw new Error("'expandedThrough' must be at most 64 characters");
+                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;
             }
         },
@@ -4803,41 +4813,31 @@ export const CalendarObject = {
         }
     },
     indexes: {
-        bySyncSequence: {
-            pk: {
-                field: "gsi1pk",
-                composite: ["calendarId"]
-            },
-            sk: {
-                field: "gsi1sk",
-                composite: ["syncSequence"]
-            },
-            index: "gsi1"
-        },
-        byUid: {
+        byMessageId: {
             pk: {
-                field: "gsi0pk",
-                composite: ["calendarId"]
+                field: "gsi2pk",
+                composite: ["messageId"]
             },
             sk: {
-                field: "gsi0sk",
-                composite: ["icalUid"]
+                field: "gsi2sk",
+                composite: ["bodyPartContentId"]
             },
-            index: "gsi0"
+            index: "gsi2",
+            collection: "messageData"
         },
-        CalendarObject: {
+        BodyPartContent: {
             pk: {
                 field: "pk",
-                composite: ["calendarId"]
+                composite: ["bodyPartContentId"]
             },
             sk: {
                 field: "sk",
-                composite: ["calendarObjectId"]
+                composite: []
             }
         }
     },
     model: {
-        entity: "calendarObject",
+        entity: "bodyPartContent",
         service: "remit",
         version: "1"
     }
@@ -4898,6 +4898,26 @@ export const CalendarEventIndex = {
             required: true,
             default: false
         },
+        summary: {
+            type: "string",
+            required: true,
+            default: "",
+            validate: value => {
+                if (typeof value === "string" && value.length > 512)
+                    throw new Error("'summary' must be at most 512 characters");
+                return true;
+            }
+        },
+        status: {
+            type: ["Confirmed", "Tentative", "Cancelled"],
+            required: true,
+            default: "Confirmed"
+        },
+        transparency: {
+            type: ["Opaque", "Transparent"],
+            required: true,
+            default: "Opaque"
+        },
         createdAt: {
             type: "number",
             readOnly: true,