@remit/electrodb-entities 0.0.19 → 0.0.21

package/index.mjs

@@ -1381,6 +1381,319 @@ export const OrganizeJobRequest = {
         version: "1"
     }
 };
+export const CalendarCollection = {
+    attributes: {
+        calendarId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                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;
+            }
+        },
+        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;
+            }
+        },
+        urlSegment: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'urlSegment' must be at most 64 characters");
+                return true;
+            }
+        },
+        displayName: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 140)
+                    throw new Error("'displayName' must be at most 140 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"
+        },
+        timezone: {
+            type: "string",
+            required: true,
+            default: "",
+            validate: value => {
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'timezone' must be at most 64 characters");
+                return true;
+            }
+        },
+        syncSequence: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'syncSequence' 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: {
+        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: 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;
+            }
+        },
+        calendarId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                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;
+            }
+        },
+        resourceName: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 256)
+                    throw new Error("'resourceName' must be at most 256 characters");
+                return true;
+            }
+        },
+        icalUid: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 512)
+                    throw new Error("'icalUid' must be at most 512 characters");
+                return true;
+            }
+        },
+        icalData: {
+            type: "string",
+            required: true
+        },
+        etag: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'etag' must be at most 64 characters");
+                return true;
+            }
+        },
+        sequence: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'sequence' must be an integer");
+                return true;
+            }
+        },
+        syncSequence: {
+            type: "number",
+            required: true,
+            default: 0,
+            validate: value => {
+                if (typeof value === "number" && !Number.isInteger(value))
+                    throw new Error("'syncSequence' must be an integer");
+                return 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;
+            }
+        },
+        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;
+            }
+        },
+        dtEnd: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'dtEnd' must be at most 64 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: {
+            type: "string",
+            required: true,
+            default: "",
+            validate: value => {
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'expandedThrough' must be at most 64 characters");
+                return true;
+            }
+        },
+        createdAt: {
+            type: "number",
+            readOnly: true,
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        },
+        updatedAt: {
+            type: "number",
+            watch: "*",
+            required: true,
+            default: () => Date.now(),
+            set: () => Date.now()
+        }
+    },
+    indexes: {
+        bySyncSequence: {
+            pk: {
+                field: "gsi1pk",
+                composite: ["calendarId"]
+            },
+            sk: {
+                field: "gsi1sk",
+                composite: ["syncSequence"]
+            },
+            index: "gsi1"
+        },
+        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: {
@@ -2939,125 +3252,22 @@ export const MessageReference = {
                 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: {
+        messageIdValue: {
             type: "string",
             required: true
         },
-        addressRole: {
-            type: ["from", "sender", "reply_to", "to", "cc", "bcc"],
+        referenceType: {
+            type: ["in_reply_to", "references"],
             required: true
         },
-        addressOrder: {
+        referenceOrder: {
             type: "number",
             required: true,
             validate: value => {
                 if (typeof value === "number" && value < 0)
-                    throw new Error("'addressOrder' must be at least 0");
+                    throw new Error("'referenceOrder' must be at least 0");
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'addressOrder' must be an integer");
+                    throw new Error("'referenceOrder' must be an integer");
                 return true;
             }
         },
@@ -3084,15 +3294,15 @@ export const EnvelopeAddress = {
             },
             sk: {
                 field: "gsi2sk",
-                composite: ["envelopeAddressId"]
+                composite: ["messageReferenceId"]
             },
             index: "gsi2",
             collection: "messageData"
         },
-        EnvelopeAddress: {
+        MessageReference: {
             pk: {
                 field: "pk",
-                composite: ["envelopeAddressId"]
+                composite: ["messageReferenceId"]
             },
             sk: {
                 field: "sk",
@@ -3101,21 +3311,21 @@ export const EnvelopeAddress = {
         }
     },
     model: {
-        entity: "envelopeAddress",
+        entity: "messageReference",
         service: "remit",
         version: "1"
     }
 };
-export const ConfigImport = {
+export const CalendarSuggestion = {
     attributes: {
-        importId: {
+        suggestionId: {
             type: "string",
             required: true,
             validate: value => {
                 if (typeof value === "string" && value.length < 25)
-                    throw new Error("'importId' must be at least 25 characters");
+                    throw new Error("'suggestionId' must be at least 25 characters");
                 if (typeof value === "string" && value.length > 25)
-                    throw new Error("'importId' must be at most 25 characters");
+                    throw new Error("'suggestionId' must be at most 25 characters");
                 return true;
             }
         },
@@ -3130,134 +3340,128 @@ export const ConfigImport = {
                 return true;
             }
         },
-        schemaVersion: {
+        messageId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'messageId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'messageId' must be at most 25 characters");
+                return true;
+            }
+        },
+        bodyPartId: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length < 25)
+                    throw new Error("'bodyPartId' must be at least 25 characters");
+                if (typeof value === "string" && value.length > 25)
+                    throw new Error("'bodyPartId' must be at most 25 characters");
+                return true;
+            }
+        },
+        icalUid: {
+            type: "string",
+            required: true,
+            validate: value => {
+                if (typeof value === "string" && value.length > 512)
+                    throw new Error("'icalUid' must be at most 512 characters");
+                return true;
+            }
+        },
+        sequence: {
             type: "number",
             required: true,
+            default: 0,
             validate: value => {
                 if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'schemaVersion' must be an integer");
+                    throw new Error("'sequence' must be an integer");
                 return true;
             }
         },
+        method: {
+            type: ["Request", "Reply", "Cancel", "Counter", "Publish", "None"],
+            required: true,
+            default: "None"
+        },
+        source: {
+            type: ["IcalendarPart", "IcalendarAttachment", "TextHeuristic"],
+            required: true,
+            default: "IcalendarPart"
+        },
         state: {
-            type: ["Pending", "Complete"],
+            type: ["Pending", "Accepted", "Declined", "Tentative", "Dismissed", "Superseded"],
             required: true,
             default: "Pending"
         },
-        document: {
-            type: CustomAttributeType("any"),
-            required: 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
-                    }
-                }
-            },
-            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;
+            }
         },
-        createdAt: {
-            type: "number",
-            readOnly: true,
+        dtStart: {
+            type: "string",
             required: true,
-            default: () => Date.now(),
-            set: () => Date.now()
+            validate: value => {
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'dtStart' must be at most 64 characters");
+                return true;
+            }
         },
-        completedAt: {
-            type: "number",
+        dtEnd: {
+            type: "string",
             required: true,
-            default: 0,
             validate: value => {
-                if (typeof value === "number" && !Number.isInteger(value))
-                    throw new Error("'completedAt' must be an integer");
+                if (typeof value === "string" && value.length > 64)
+                    throw new Error("'dtEnd' must be at most 64 characters");
                 return true;
             }
         },
-        updatedAt: {
-            type: "number",
-            watch: "*",
+        allDay: {
+            type: "boolean",
             required: true,
-            default: () => Date.now(),
-            set: () => Date.now()
-        }
-    },
-    indexes: {
-        byAccountConfigId: {
-            pk: {
-                field: "gsi0pk",
-                composite: ["accountConfigId"]
-            },
-            sk: {
-                field: "gsi0sk",
-                composite: ["createdAt"]
-            },
-            index: "gsi0"
+            default: false
         },
-        ConfigImport: {
-            pk: {
-                field: "pk",
-                composite: ["importId"]
-            },
-            sk: {
-                field: "sk",
-                composite: []
-            }
-        }
-    },
-    model: {
-        entity: "configImport",
-        service: "remit",
-        version: "1"
-    }
-};
-export const AccountSetting = {
-    attributes: {
-        accountSettingId: {
+        location: {
             type: "string",
             required: true,
+            default: "",
             validate: value => {
-                if (typeof value === "string" && value.length < 25)
-                    throw new Error("'accountSettingId' must be at least 25 characters");
-                if (typeof value === "string" && value.length > 25)
-                    throw new Error("'accountSettingId' must be at most 25 characters");
+                if (typeof value === "string" && value.length > 512)
+                    throw new Error("'location' must be at most 512 characters");
                 return true;
             }
         },
-        accountConfigId: {
+        organizer: {
             type: "string",
             required: true,
+            default: "",
             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 > 256)
+                    throw new Error("'organizer' must be at most 256 characters");
                 return true;
             }
         },
-        name: {
+        zoneCertainty: {
+            type: ["Local", "Explicit", "Ambiguous"],
+            required: true,
+            default: "Explicit"
+        },
+        icalData: {
             type: "string",
-            required: true
+            required: true,
+            default: ""
         },
-        value: {
-            type: CustomAttributeType("any"),
-            required: true
+        acceptedCalendarObjectId: {
+            type: "string",
+            required: true,
+            default: ""
         },
         createdAt: {
             type: "number",
@@ -3275,202 +3479,135 @@ export const AccountSetting = {
         }
     },
     indexes: {
-        byAccountConfigId: {
-            pk: {
-                field: "gsi0pk",
-                composite: ["accountConfigId"]
-            },
-            sk: {
-                field: "gsi0sk",
-                composite: ["name"]
-            },
-            index: "gsi0"
-        },
-        AccountSetting: {
-            pk: {
-                field: "pk",
-                composite: ["accountSettingId"]
-            },
-            sk: {
-                field: "sk",
-                composite: []
-            }
-        }
-    },
-    model: {
-        entity: "accountSetting",
-        service: "remit",
-        version: "1"
-    }
-};
-export const MailboxAttributeEntry = {
-    attributes: {
-        mailboxAttributeId: {
-            type: "string",
-            required: true,
-            validate: value => {
-                if (typeof value === "string" && value.length < 25)
-                    throw new Error("'mailboxAttributeId' must be at least 25 characters");
-                if (typeof value === "string" && value.length > 25)
-                    throw new Error("'mailboxAttributeId' must be at most 25 characters");
-                return true;
-            }
-        },
-        mailboxId: {
-            type: "string",
-            required: true,
-            validate: value => {
-                if (typeof value === "string" && value.length < 25)
-                    throw new Error("'mailboxId' must be at least 25 characters");
-                if (typeof value === "string" && value.length > 25)
-                    throw new Error("'mailboxId' must be at most 25 characters");
-                return true;
-            }
-        },
-        attributeName: {
-            type: ["\NonExistent", "\Noinferiors", "\Noselect", "\HasChildren", "\HasNoChildren", "\Marked", "\Unmarked", "\Subscribed", "\Remote"],
-            required: true
-        }
-    },
-    indexes: {
-        byMailboxId: {
+        byState: {
             pk: {
                 field: "gsi1pk",
-                composite: ["mailboxId"]
+                composite: ["accountConfigId"]
             },
             sk: {
                 field: "gsi1sk",
-                composite: ["mailboxAttributeId"]
+                composite: ["state", "createdAt", "suggestionId"]
             },
-            index: "gsi1",
-            collection: "mailbox"
+            index: "gsi1"
         },
-        MailboxAttributeEntry: {
+        byMessage: {
+            pk: {
+                field: "gsi0pk",
+                composite: ["accountConfigId"]
+            },
+            sk: {
+                field: "gsi0sk",
+                composite: ["messageId", "suggestionId"]
+            },
+            index: "gsi0"
+        },
+        CalendarSuggestion: {
             pk: {
                 field: "pk",
-                composite: ["mailboxAttributeId"]
+                composite: ["accountConfigId"]
             },
             sk: {
                 field: "sk",
-                composite: []
+                composite: ["suggestionId"]
             }
         }
     },
     model: {
-        entity: "mailboxAttributeEntry",
+        entity: "calendarSuggestion",
         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 +3616,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 +3790,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 +3813,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 +3994,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 +4027,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 +4126,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 +4162,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 +4179,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 +4262,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 +4365,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 +4472,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 +4489,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 +4579,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 +4631,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 +4667,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 +4684,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 +4785,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 +5015,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 +5100,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,