@codecks/fetch 0.0.1

package/dist/index.js

@@ -0,0 +1,3214 @@
+//#region src/collection-utils.ts
+const ensureMapValue = (map, key, fallback) => {
+	const exist = map.get(key);
+	if (exist) return exist;
+	const newValue = fallback();
+	map.set(key, newValue);
+	return newValue;
+};
+
+//#endregion
+//#region src/models/_desc.ts
+const makeModel = (opts) => {
+	return opts;
+};
+const relation = (relName, options) => {
+	return {
+		relName,
+		options
+	};
+};
+
+//#endregion
+//#region src/models/_root.ts
+const _rootDesc = makeModel({
+	name: "_root",
+	fields: {},
+	relations: {
+		releases: relation("release", { type: "hasMany" }),
+		accountOnboardingSteps: relation("accountOnboardingStep", { type: "hasMany" }),
+		apps: relation("app", { type: "hasMany" }),
+		account: relation("account", { type: "hasOne" }),
+		loggedInUser: relation("user", { type: "hasOne" }),
+		cardsStatusHistory: relation("cardsStatusHistory", { type: "hasMany" }),
+		cardsEffortHistory: relation("cardsEffortHistory", { type: "hasMany" }),
+		cardsFinishedHistory: relation("cardsFinishedHistory", { type: "hasMany" }),
+		cardsTimeToFinished: relation("cardsTimeToFinished", { type: "hasMany" })
+	},
+	keys: []
+});
+
+//#endregion
+//#region src/model-pool.ts
+const ROOT_ID = "";
+const dateStrToDay = (dateAsStr) => {
+	const parts = dateAsStr.split("-");
+	return {
+		year: parseInt(parts[0], 10),
+		month: parseInt(parts[1], 10),
+		day: parseInt(parts[2], 10)
+	};
+};
+const parseField = (v, field) => {
+	if (!field) return v;
+	switch (field.type) {
+		case "date": return new Date(v);
+		case "day": return dateStrToDay(v);
+		default: return v;
+	}
+};
+const transformData = (desc, data) => {
+	return Object.fromEntries(Object.entries(data).map(([k, v]) => [k, parseField(v, desc.fields[k])]));
+};
+var ModelPool = class {
+	data = new Map();
+	modelMap;
+	constructor(modelMap$1) {
+		this.modelMap = modelMap$1;
+	}
+	addModelInstance(model, id$1, _data) {
+		const instanceById = ensureMapValue(this.data, model, () => new Map());
+		const exists = instanceById.get(id$1);
+		const desc = this.modelMap[model];
+		if (!desc) throw new Error(`Unknown model: ${model}`);
+		const data = transformData(desc, _data);
+		if (exists) Object.assign(exists, data);
+		else instanceById.set(id$1, data);
+	}
+	add(data) {
+		Object.entries(data).forEach(([modelName, payload]) => {
+			if (modelName === _rootDesc.name) this.addModelInstance(modelName, ROOT_ID, payload);
+			else Object.entries(payload).forEach(([id$1, payload$1]) => {
+				this.addModelInstance(modelName, id$1, payload$1);
+			});
+		});
+	}
+	get(model, id$1) {
+		const instances = this.data.get(model);
+		if (!instances) return null;
+		return instances.get(id$1) ?? null;
+	}
+};
+
+//#endregion
+//#region src/models/_fields.ts
+const id = () => {
+	return { type: "id" };
+};
+const string = (opts) => {
+	return { type: "string" };
+};
+const int = (opts) => {
+	return { type: "int" };
+};
+const bigint = (opts) => {
+	return { type: "bigint" };
+};
+const bool = (opts) => {
+	return { type: "bool" };
+};
+const date = (opts) => {
+	return { type: "date" };
+};
+const day = (opts) => {
+	return { type: "day" };
+};
+const object = (opts) => {
+	return { type: "obj" };
+};
+const array = (opts) => {
+	return { type: "array" };
+};
+const belongsTo = (opts) => {
+	return { type: () => {
+		return { type: "belongsTo" };
+	} };
+};
+
+//#endregion
+//#region src/models/AccountOnboardingStep.ts
+const accountOnboardingStepDesc = makeModel({
+	name: "accountOnboardingStep",
+	fields: {
+		key: id(),
+		title: string({}),
+		description: string({}),
+		chapter: string({}),
+		sortValue: string({}),
+		variants: array({}),
+		xp: int({}),
+		milestone: string({})
+	},
+	relations: {},
+	keys: ["key"]
+});
+
+//#endregion
+//#region src/models/File.ts
+const fileDesc = makeModel({
+	name: "file",
+	fields: {
+		id: id(),
+		name: string({}),
+		url: string({}),
+		size: string({}),
+		isDeleted: string({}),
+		meta: object({}),
+		createdAt: date({}),
+		deletedAt: date({}),
+		selfHosted: string({}),
+		accountId: belongsTo({}).type(),
+		uploaderId: belongsTo({}).type(),
+		deletedById: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		uploader: relation("user", {
+			type: "belongsTo",
+			fk: "uploaderId"
+		}),
+		deletedBy: relation("user", {
+			type: "belongsTo",
+			fk: "deletedById"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Release.ts
+const releaseDesc = makeModel({
+	name: "release",
+	fields: {
+		id: id(),
+		version: string({}),
+		isLive: string({}),
+		content: string({}),
+		title: string({}),
+		createdAt: date({})
+	},
+	relations: {},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/User.ts
+const userDesc = makeModel({
+	name: "user",
+	fields: {
+		id: id(),
+		name: string({}),
+		fullName: string({ optional: true }),
+		timezone: string({ optional: true }),
+		createdAt: date({}),
+		hasPassword: bool({}),
+		showCardIdInTimer: bool({}),
+		disableMovingImages: bool({}),
+		autoMeFilterCardLimit: int({ optional: true }),
+		isIntegration: bool({}),
+		statusColorPalette: string({}),
+		wantsNewsletter: bool({ optional: true }),
+		wantsDailyDigestMail: bool({ optional: true }),
+		wantsConvoDigestMail: bool({ optional: true }),
+		disableAnimations: bool({}),
+		enableClickToEditCards: bool({}),
+		cdxRole: string({}),
+		profileImageId: belongsTo({ optional: true }).type(),
+		lastSeenReleaseId: belongsTo({}).type()
+	},
+	relations: {
+		profileImage: relation("file", {
+			type: "belongsTo",
+			fk: "profileImageId"
+		}),
+		lastSeenRelease: relation("release", {
+			type: "belongsTo",
+			fk: "lastSeenReleaseId"
+		}),
+		projectOrders: relation("projectOrder", { type: "hasMany" }),
+		projectSelections: relation("projectSelection", { type: "hasMany" }),
+		queueSelections: relation("queueSelection", { type: "hasMany" }),
+		accountRoles: relation("accountRole", { type: "hasMany" }),
+		cardDiffNotifications: relation("cardDiffNotification", { type: "hasMany" }),
+		resolvableNotifications: relation("resolvableNotification", { type: "hasMany" }),
+		publicProjectMembership: relation("publicProjectMembership", { type: "hasMany" }),
+		lastSeenCardUpvotes: relation("lastSeenCardUpvote", { type: "hasMany" }),
+		dueCards: relation("dueCard", { type: "hasMany" }),
+		assigneeDeckAssignments: relation("assigneeDeckAssignment", { type: "hasMany" }),
+		autoFinishedTimeTrackingSegments: relation("autoFinishedTimeTrackingSegment", { type: "hasMany" }),
+		savedSearches: relation("savedSearch", { type: "hasMany" }),
+		activities: relation("activity", { type: "hasMany" }),
+		emails: relation("userEmail", { type: "hasMany" }),
+		tags: relation("userTag", { type: "hasMany" }),
+		unverifiedEmails: relation("userEmail", { type: "hasMany" }),
+		primaryEmail: relation("userEmail", { type: "hasOne" }),
+		pinnedMilestoneNext: relation("pinnedMilestone", { type: "hasOne" }),
+		projectAccess: relation("projectUser", { type: "hasMany" }),
+		explicitProjectAccess: relation("projectUser", { type: "hasMany" }),
+		withProjectAccess: relation("userProjectAccess", { type: "hasMany" }),
+		projectSettings: relation("projectUserSetting", { type: "hasMany" }),
+		accountSettings: relation("accountUserSetting", { type: "hasMany" }),
+		dismissedHints: relation("userDismissedHint", { type: "hasMany" }),
+		slackIntegrations: relation("integration", { type: "hasMany" }),
+		activeTimeTracker: relation("activeTimeTracker", { type: "hasOne" }),
+		participations: relation("resolvableParticipant", { type: "hasMany" }),
+		upvotes: relation("cardUpvote", { type: "hasMany" }),
+		userOnboarding: relation("userOnboarding", { type: "hasOne" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Account.ts
+const accountDesc = makeModel({
+	name: "account",
+	fields: {
+		id: id(),
+		subdomain: string({}),
+		name: string({}),
+		billingName: string({ optional: true }),
+		billingLine1: string({ optional: true }),
+		billingLine2: string({ optional: true }),
+		billingZip: string({ optional: true }),
+		billingCity: string({ optional: true }),
+		billingCountryCode: string({ optional: true }),
+		billingEmail: string({ optional: true }),
+		netGiftAmount: int({}),
+		persona: string({ optional: true }),
+		createdAt: date({}),
+		disabledAt: date({ optional: true }),
+		totalMediaByteUsage: bigint({}),
+		isDisabled: string({}),
+		milestonesEnabled: string({}),
+		sprintsEnabled: string({}),
+		priorityLabels: object({}),
+		effortScale: object({}),
+		statusChangeDurations: object({}),
+		activeFeatureFlags: object({}),
+		timeTrackingMode: string({}),
+		maxTimeTrackingSegmentMsDuration: int({}),
+		timeTrackingSwimLaneInfo: bool({}),
+		workdays: string({}),
+		workflowMode: string({}),
+		isLearning: bool({}),
+		isNonProfit: bool({}),
+		dependenciesEnabled: bool({}),
+		maxHandSlotCount: int({}),
+		seats: int({}),
+		activeProjectCount: int({}),
+		billingType: string({}),
+		allowInheritHeroCover: bool({}),
+		attachmentCoverMode: string({}),
+		staffPermission: string({}),
+		offeringTrial: bool({}),
+		coupon: object({ optional: true }),
+		hideCompletedCardCountForDecks: bool({}),
+		visionBoardEnabled: bool({}),
+		fallbackEffort: int({}),
+		timelineScaleType: string({}),
+		startWeekday: string({}),
+		disabledById: belongsTo({ optional: true }).type()
+	},
+	relations: {
+		disabledBy: relation("user", {
+			type: "belongsTo",
+			fk: "disabledById"
+		}),
+		cards: relation("card", { type: "hasMany" }),
+		invoices: relation("invoice", { type: "hasMany" }),
+		cardPresets: relation("cardPreset", { type: "hasMany" }),
+		attachments: relation("attachment", { type: "hasMany" }),
+		discordGuilds: relation("discordGuild", { type: "hasMany" }),
+		timeTrackingSegments: relation("timeTrackingSegment", { type: "hasMany" }),
+		workflowItems: relation("workflowItem", { type: "hasMany" }),
+		deckAssignments: relation("deckAssignment", { type: "hasMany" }),
+		assigneeAssignments: relation("assigneeAssignment", { type: "hasMany" }),
+		assigneeDeckAssignments: relation("assigneeDeckAssignment", { type: "hasMany" }),
+		wizards: relation("wizard", { type: "hasMany" }),
+		milestones: relation("milestone", { type: "hasMany" }),
+		sprints: relation("sprint", { type: "hasMany" }),
+		sprintConfigs: relation("sprintConfig", { type: "hasMany" }),
+		handCards: relation("handCard", { type: "hasMany" }),
+		resolvables: relation("resolvable", { type: "hasMany" }),
+		cardUpvotes: relation("cardUpvote", { type: "hasMany" }),
+		resolvableParticipants: relation("resolvableParticipant", { type: "hasMany" }),
+		userReportSettings: relation("userReportSetting", { type: "hasMany" }),
+		cardOrders: relation("cardOrder", { type: "hasMany" }),
+		accountUserAchievements: relation("accountUserAchievement", { type: "hasMany" }),
+		userInviteCodes: relation("userInviteCode", { type: "hasMany" }),
+		visionBoards: relation("visionBoard", { type: "hasMany" }),
+		deckSubscriptions: relation("deckSubscription", { type: "hasMany" }),
+		appInstallations: relation("appInstallation", { type: "hasMany" }),
+		files: relation("file", { type: "hasMany" }),
+		decks: relation("deck", { type: "hasMany" }),
+		queueEntries: relation("queueEntry", { type: "hasMany" }),
+		visionBoardQueries: relation("visionBoardQuery", { type: "hasMany" }),
+		anyDecks: relation("deck", { type: "hasMany" }),
+		projects: relation("project", { type: "hasMany" }),
+		archivedProjects: relation("project", { type: "hasMany" }),
+		anyProjects: relation("project", { type: "hasMany" }),
+		roles: relation("accountRole", { type: "hasMany" }),
+		invitations: relation("userInvitation", { type: "hasMany" }),
+		githubIntegration: relation("integration", { type: "hasOne" }),
+		slackIntegration: relation("integration", { type: "hasOne" }),
+		affiliateCodes: relation("affiliateCode", { type: "hasMany" }),
+		activities: relation("activity", { type: "hasMany" }),
+		stripeAccountSync: relation("stripeAccountSync", { type: "hasOne" }),
+		accountOnboarding: relation("accountOnboarding", { type: "hasOne" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/AccountOnboarding.ts
+const accountOnboardingDesc = makeModel({
+	name: "accountOnboarding",
+	fields: {
+		variants: array({}),
+		steps: object({}),
+		accountId: belongsTo({}).type()
+	},
+	relations: { account: relation("account", {
+		type: "belongsTo",
+		fk: "accountId"
+	}) },
+	keys: ["accountId"]
+});
+
+//#endregion
+//#region src/models/AccountRole.ts
+const accountRoleDesc = makeModel({
+	name: "accountRole",
+	fields: {
+		role: string({}),
+		createdAt: date({}),
+		lastChangedAt: date({}),
+		roleAsPrio: int({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["accountId", "userId"]
+});
+
+//#endregion
+//#region src/models/AccountUserAchievement.ts
+const accountUserAchievementDesc = makeModel({
+	name: "accountUserAchievement",
+	fields: {
+		value: object({}),
+		context: object({}),
+		accountId: belongsTo({}).type(),
+		userId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		})
+	},
+	keys: [
+		"accountId",
+		"userId",
+		"key"
+	]
+});
+
+//#endregion
+//#region src/models/Project.ts
+const projectDesc = makeModel({
+	name: "project",
+	fields: {
+		id: id(),
+		name: string({}),
+		visibility: string({}),
+		defaultUserAccess: string({}),
+		createdAt: date({}),
+		accountSeq: int({}),
+		allowUpvotes: string({}),
+		isPublic: string({}),
+		commentsArePublic: string({}),
+		publicRegistryAgreement: string({ optional: true }),
+		publicLayoutVersion: string({}),
+		publicIsExplicit: string({}),
+		markerColor: string({ optional: true }),
+		effortIcon: string({ optional: true }),
+		spaces: string({}),
+		publicPath: string({ optional: true }),
+		publicMessage: string({ optional: true }),
+		publicHeading: string({ optional: true }),
+		publicBackgroundColor: string({ optional: true }),
+		accountId: belongsTo({}).type(),
+		coverFileId: belongsTo({ optional: true }).type(),
+		publicBannerFileId: belongsTo({ optional: true }).type(),
+		publicTileFileId: belongsTo({ optional: true }).type(),
+		publicBackgroundImageId: belongsTo({ optional: true }).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId"
+		}),
+		publicBannerFile: relation("file", {
+			type: "belongsTo",
+			fk: "publicBannerFileId"
+		}),
+		publicTileFile: relation("file", {
+			type: "belongsTo",
+			fk: "publicTileFileId"
+		}),
+		publicBackgroundImage: relation("file", {
+			type: "belongsTo",
+			fk: "publicBackgroundImageId"
+		}),
+		decks: relation("deck", { type: "hasMany" }),
+		milestoneProjects: relation("milestoneProject", { type: "hasMany" }),
+		sprintProjects: relation("sprintProject", { type: "hasMany" }),
+		publicProjectVisits: relation("publicProjectVisit", { type: "hasMany" }),
+		dailyPublicProjectMembership: relation("dailyPublicProjectMembership", { type: "hasMany" }),
+		publicProjectMemberships: relation("publicProjectMembership", { type: "hasMany" }),
+		cardUpvotes: relation("cardUpvote", { type: "hasMany" }),
+		tags: relation("projectTag", { type: "hasMany" }),
+		activities: relation("activity", { type: "hasMany" }),
+		explicitProjectUsers: relation("projectUser", { type: "hasMany" }),
+		access: relation("userProjectAccess", { type: "hasMany" }),
+		publicProjectInfo: relation("publicProjectInfo", { type: "hasOne" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Milestone.ts
+const milestoneDesc = makeModel({
+	name: "milestone",
+	fields: {
+		id: id(),
+		name: string({}),
+		color: string({}),
+		date: day({}),
+		startDate: day({ optional: true }),
+		createdAt: date({}),
+		accountSeq: int({}),
+		description: string({ optional: true }),
+		isGlobal: string({}),
+		handSyncEnabled: string({}),
+		manualOrderLabels: string({}),
+		stats: object({}),
+		userCapacities: object({}),
+		isDeleted: bool({}),
+		preferredOrder: string({ optional: true }),
+		accountId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type(),
+		coverFileId: belongsTo({ optional: true }).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId"
+		}),
+		milestoneProjects: relation("milestoneProject", { type: "hasMany" }),
+		cards: relation("card", { type: "hasMany" }),
+		activities: relation("activity", { type: "hasMany" }),
+		progress: relation("milestoneProgress", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/ProjectTag.ts
+const projectTagDesc = makeModel({
+	name: "projectTag",
+	fields: {
+		id: id(),
+		tag: string({}),
+		color: string({ optional: true }),
+		emoji: string({ optional: true }),
+		description: string({ optional: true }),
+		createdAt: date({}),
+		projectId: belongsTo({}).type()
+	},
+	relations: { project: relation("project", {
+		type: "belongsTo",
+		fk: "projectId"
+	}) },
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Deck.ts
+const deckDesc = makeModel({
+	name: "deck",
+	fields: {
+		id: id(),
+		content: string({}),
+		description: string({}),
+		title: string({}),
+		sortValue: string({}),
+		preferredOrder: string({ optional: true }),
+		coverColor: string({ optional: true }),
+		isDeleted: string({}),
+		accountSeq: int({}),
+		spaceId: int({ optional: true }),
+		defaultCard: object({}),
+		isOnboardingDeck: bool({}),
+		handSyncEnabled: string({}),
+		stickyDefaultProjectTag: string({}),
+		manualOrderLabels: string({}),
+		workflowItemOrderLabels: string({}),
+		createdAt: date({}),
+		stats: object({}),
+		hasGuardians: string({}),
+		allowedCardTypes: string({}),
+		projectId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		milestoneId: belongsTo({ optional: true }).type(),
+		creatorId: belongsTo({}).type(),
+		coverFileId: belongsTo({ optional: true }).type(),
+		descriptionCoverFileId: belongsTo({ optional: true }).type(),
+		defaultProjectTagId: belongsTo({ optional: true }).type()
+	},
+	relations: {
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		milestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "milestoneId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId"
+		}),
+		descriptionCoverFile: relation("file", {
+			type: "belongsTo",
+			fk: "descriptionCoverFileId"
+		}),
+		defaultProjectTag: relation("projectTag", {
+			type: "belongsTo",
+			fk: "defaultProjectTagId"
+		}),
+		cards: relation("card", { type: "hasMany" }),
+		workflowItems: relation("workflowItem", { type: "hasMany" }),
+		cardOrderInDecks: relation("cardOrderInDeck", { type: "hasMany" }),
+		activities: relation("activity", { type: "hasMany" }),
+		guardians: relation("deckGuardian", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/AccountUserSetting.ts
+const accountUserSettingDesc = makeModel({
+	name: "accountUserSetting",
+	fields: {
+		wantsWeeklyDigestMail: bool({}),
+		timelineScaleTypeOverwrite: string({}),
+		startWeekdayOverwrite: string({}),
+		accountId: belongsTo({}).type(),
+		userId: belongsTo({}).type(),
+		inboxDeckId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		inboxDeck: relation("deck", {
+			type: "belongsTo",
+			fk: "inboxDeckId"
+		})
+	},
+	keys: ["accountId", "userId"]
+});
+
+//#endregion
+//#region src/models/SprintConfig.ts
+const sprintConfigDesc = makeModel({
+	name: "sprintConfig",
+	fields: {
+		id: id(),
+		name: string({}),
+		color: string({}),
+		stopOn: day({ optional: true }),
+		isGlobal: string({}),
+		upcomingSprints: int({}),
+		sprintDurationWeeks: int({}),
+		sprintStartWeekday: int({}),
+		endHour: int({}),
+		endHourTimezone: string({}),
+		createdAt: date({}),
+		preferredOrder: string({ optional: true }),
+		moveOnFinish: string({}),
+		autoBeastModeDurationHours: int({ optional: true }),
+		autoAssignStartedCard: bool({}),
+		autoAssignNewCard: bool({}),
+		beastGracePeriodHours: int({}),
+		accountId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		sprintProjects: relation("sprintProject", { type: "hasMany" }),
+		sprints: relation("sprint", { type: "hasMany" }),
+		progress: relation("sprintConfigProgress", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Sprint.ts
+const sprintDesc = makeModel({
+	name: "sprint",
+	fields: {
+		id: id(),
+		description: string({}),
+		name: string({ optional: true }),
+		accountSeq: int({}),
+		index: int({}),
+		startDate: day({}),
+		endDate: day({}),
+		stats: object({}),
+		manualOrderLabels: string({}),
+		userCapacities: object({}),
+		handSyncEnabled: string({}),
+		createdAt: date({}),
+		isDeleted: bool({}),
+		completedAt: date({ optional: true }),
+		lockedAt: date({ optional: true }),
+		accountId: belongsTo({}).type(),
+		sprintConfigId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type(),
+		coverFileId: belongsTo({ optional: true }).type(),
+		autoMilestoneId: belongsTo({ optional: true }).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		sprintConfig: relation("sprintConfig", {
+			type: "belongsTo",
+			fk: "sprintConfigId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId"
+		}),
+		autoMilestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "autoMilestoneId"
+		}),
+		cards: relation("card", { type: "hasMany" }),
+		progress: relation("sprintProgress", { type: "hasMany" }),
+		activities: relation("activity", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/WorkflowItem.ts
+const workflowItemDesc = makeModel({
+	name: "workflowItem",
+	fields: {
+		itemId: id(),
+		version: string({}),
+		sortOrder: string({}),
+		sortValue: string({}),
+		priority: string({ optional: true }),
+		content: string({}),
+		createdAt: date({}),
+		lastUpdatedAt: date({}),
+		tags: array({}),
+		masterTags: array({}),
+		mentionedUsers: array({}),
+		title: string({}),
+		effort: int({ optional: true }),
+		label: string({ optional: true }),
+		checkboxStats: object({}),
+		accountSeq: int({}),
+		checkboxInfo: array({}),
+		visibility: string({}),
+		accountId: belongsTo({}).type(),
+		deckId: belongsTo({}).type(),
+		targetDeckId: belongsTo({ optional: true }).type(),
+		assigneeId: belongsTo({ optional: true }).type(),
+		creatorId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId"
+		}),
+		targetDeck: relation("deck", {
+			type: "belongsTo",
+			fk: "targetDeckId"
+		}),
+		assignee: relation("user", {
+			type: "belongsTo",
+			fk: "assigneeId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		diffs: relation("workflowItemHistory", { type: "hasMany" }),
+		inDeps: relation("workflowItem", { type: "hasMany" }),
+		outDeps: relation("workflowItem", { type: "hasMany" })
+	},
+	keys: ["itemId"]
+});
+
+//#endregion
+//#region src/models/DiscordGuild.ts
+const discordGuildDesc = makeModel({
+	name: "discordGuild",
+	fields: {
+		id: id(),
+		discordGuildId: string({}),
+		guildName: string({}),
+		guildIconId: string({}),
+		scope: string({}),
+		karmaRoleThresholds: object({}),
+		removeCommandEnabled: string({}),
+		removeCommandEmoji: string({}),
+		removeCommandRoleId: string({}),
+		createdAt: date({}),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		slashCommands: relation("discordSlashCommand", { type: "hasMany" }),
+		projectNotifications: relation("discordProjectNotification", { type: "hasMany" }),
+		dailyDiscordGuildVoteMemberships: relation("dailyDiscordGuildVoteMembership", { type: "hasMany" }),
+		members: relation("discordMember", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/VisionBoard.ts
+const visionBoardDesc = makeModel({
+	name: "visionBoard",
+	fields: {
+		id: id(),
+		accountSeq: int({}),
+		createdAt: date({}),
+		isDeleted: bool({}),
+		cardId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Card.ts
+const cardDesc = makeModel({
+	name: "card",
+	fields: {
+		cardId: id(),
+		version: int({}),
+		accountSeq: int({}),
+		content: string({}),
+		status: string({}),
+		derivedStatus: string({}),
+		createdAt: date({}),
+		lastUpdatedAt: date({}),
+		tags: array({}),
+		masterTags: array({}),
+		mentionedUsers: array({}),
+		title: string({}),
+		priority: string({ optional: true }),
+		effort: int({ optional: true }),
+		checkboxStats: object({}),
+		checkboxInfo: array({}),
+		visibility: string({}),
+		legacyProjectSeq: int({ optional: true }),
+		meta: object({}),
+		embeds: object({}),
+		isPublic: bool({}),
+		hasBlockingDeps: bool({}),
+		dueDate: day({ optional: true }),
+		isDoc: bool({ optional: true }),
+		childCardInfo: string({}),
+		accountId: belongsTo({}).type(),
+		deckId: belongsTo({ optional: true }).type(),
+		assigneeId: belongsTo({ optional: true }).type(),
+		creatorId: belongsTo({ optional: true }).type(),
+		milestoneId: belongsTo({ optional: true }).type(),
+		sprintId: belongsTo({ optional: true }).type(),
+		legacyProjectId: belongsTo({ optional: true }).type(),
+		coverFileId: belongsTo({ optional: true }).type(),
+		parentCardId: belongsTo({ optional: true }).type(),
+		sourceWorkflowItemId: belongsTo({ optional: true }).type(),
+		discordGuildId: belongsTo({}).type(),
+		visionBoardId: belongsTo({ optional: true }).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId"
+		}),
+		assignee: relation("user", {
+			type: "belongsTo",
+			fk: "assigneeId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		milestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "milestoneId"
+		}),
+		sprint: relation("sprint", {
+			type: "belongsTo",
+			fk: "sprintId"
+		}),
+		legacyProject: relation("project", {
+			type: "belongsTo",
+			fk: "legacyProjectId"
+		}),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId"
+		}),
+		parentCard: relation("card", {
+			type: "belongsTo",
+			fk: "parentCardId"
+		}),
+		sourceWorkflowItem: relation("workflowItem", {
+			type: "belongsTo",
+			fk: "sourceWorkflowItemId"
+		}),
+		discordGuild: relation("discordGuild", {
+			type: "belongsTo",
+			fk: "discordGuildId"
+		}),
+		visionBoard: relation("visionBoard", {
+			type: "belongsTo",
+			fk: "visionBoardId"
+		}),
+		resolvables: relation("resolvable", { type: "hasMany" }),
+		handCards: relation("handCard", { type: "hasMany" }),
+		timeTrackingSegments: relation("timeTrackingSegment", { type: "hasMany" }),
+		cardSubscriptions: relation("cardSubscription", { type: "hasMany" }),
+		cardOrders: relation("cardOrder", { type: "hasMany" }),
+		resolvableEntries: relation("resolvableEntry", { type: "hasMany" }),
+		queueEntries: relation("queueEntry", { type: "hasMany" }),
+		attachments: relation("attachment", { type: "hasMany" }),
+		diffs: relation("cardHistory", { type: "hasMany" }),
+		totalTimeTrackingSums: relation("timeTrackingSum", { type: "hasOne" }),
+		userTimeTrackingSums: relation("timeTrackingSum", { type: "hasMany" }),
+		childCards: relation("card", { type: "hasMany" }),
+		inDeps: relation("card", { type: "hasMany" }),
+		outDeps: relation("card", { type: "hasMany" }),
+		cardReferences: relation("card", { type: "hasMany" }),
+		upvotes: relation("cardUpvote", { type: "hasMany" })
+	},
+	keys: ["cardId"]
+});
+
+//#endregion
+//#region src/models/ActiveTimeTracker.ts
+const activeTimeTrackerDesc = makeModel({
+	name: "activeTimeTracker",
+	fields: {
+		id: id(),
+		createdAt: date({}),
+		cardId: belongsTo({}).type(),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Activity.ts
+const activityDesc = makeModel({
+	name: "activity",
+	fields: {
+		id: id(),
+		type: string({}),
+		data: object({}),
+		isRemovedFromDeckEntry: bool({}),
+		isRemovedFromMilestoneEntry: bool({}),
+		isRemovedFromSprintEntry: bool({}),
+		createdAt: date({}),
+		cardId: belongsTo({}).type(),
+		deckId: belongsTo({}).type(),
+		projectId: belongsTo({}).type(),
+		milestoneId: belongsTo({}).type(),
+		sprintId: belongsTo({}).type(),
+		changerId: belongsTo({}).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		milestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "milestoneId"
+		}),
+		sprint: relation("sprint", {
+			type: "belongsTo",
+			fk: "sprintId"
+		}),
+		changer: relation("user", {
+			type: "belongsTo",
+			fk: "changerId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/AffiliateCode.ts
+const affiliateCodeDesc = makeModel({
+	name: "affiliateCode",
+	fields: {
+		id: id(),
+		code: string({}),
+		vanityUrl: string({}),
+		message: string({}),
+		label: string({}),
+		isDisabled: string({}),
+		isDeleted: string({}),
+		validUntil: string({}),
+		remainingRedemptions: string({}),
+		reward: object({}),
+		createdAt: date({}),
+		accountId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		stats: relation("affiliateCodeStat", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/AffiliateCodeStat.ts
+const affiliateCodeStatDesc = makeModel({
+	name: "affiliateCodeStat",
+	fields: {
+		month: int({}),
+		year: int({}),
+		visits: int({}),
+		newVisitors: int({}),
+		signups: int({}),
+		revenue: int({}),
+		affiliateCodeId: belongsTo({}).type()
+	},
+	relations: { affiliateCode: relation("affiliateCode", {
+		type: "belongsTo",
+		fk: "affiliateCodeId"
+	}) },
+	keys: ["affiliateCodeId", "month"]
+});
+
+//#endregion
+//#region src/models/App.ts
+const appDesc = makeModel({
+	name: "app",
+	fields: {
+		id: id(),
+		name: string({}),
+		createdAt: date({}),
+		payload: object({})
+	},
+	relations: {},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/AppInstallation.ts
+const appInstallationDesc = makeModel({
+	name: "appInstallation",
+	fields: {
+		id: id(),
+		createdAt: date({}),
+		accountId: belongsTo({}).type(),
+		appId: belongsTo({}).type(),
+		installerId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		app: relation("app", {
+			type: "belongsTo",
+			fk: "appId"
+		}),
+		installer: relation("user", {
+			type: "belongsTo",
+			fk: "installerId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/AssigneeAssignment.ts
+const assigneeAssignmentDesc = makeModel({
+	name: "assigneeAssignment",
+	fields: {
+		lastAssignedAt: date({}),
+		accountId: belongsTo({}).type(),
+		assigneeId: belongsTo({}).type(),
+		assignedById: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		assignee: relation("user", {
+			type: "belongsTo",
+			fk: "assigneeId"
+		}),
+		assignedBy: relation("user", {
+			type: "belongsTo",
+			fk: "assignedById"
+		})
+	},
+	keys: ["assigneeId", "assignedById"]
+});
+
+//#endregion
+//#region src/models/AssigneeDeckAssignment.ts
+const assigneeDeckAssignmentDesc = makeModel({
+	name: "assigneeDeckAssignment",
+	fields: {
+		lastAssignedAt: date({}),
+		accountId: belongsTo({}).type(),
+		deckId: belongsTo({}).type(),
+		assigneeId: belongsTo({}).type(),
+		assignedById: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId"
+		}),
+		assignee: relation("user", {
+			type: "belongsTo",
+			fk: "assigneeId"
+		}),
+		assignedBy: relation("user", {
+			type: "belongsTo",
+			fk: "assignedById"
+		})
+	},
+	keys: [
+		"assigneeId",
+		"assignedById",
+		"deckId"
+	]
+});
+
+//#endregion
+//#region src/models/Attachment.ts
+const attachmentDesc = makeModel({
+	name: "attachment",
+	fields: {
+		id: id(),
+		content: string({}),
+		title: string({}),
+		createdAt: date({}),
+		fileId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type()
+	},
+	relations: {
+		file: relation("file", {
+			type: "belongsTo",
+			fk: "fileId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/TimeTrackingSegment.ts
+const timeTrackingSegmentDesc = makeModel({
+	name: "timeTrackingSegment",
+	fields: {
+		id: id(),
+		createdAt: date({}),
+		finishedAt: date({ optional: true }),
+		startedAt: date({}),
+		modifyDurationMsBy: int({}),
+		addedManually: string({}),
+		autoFinishedState: string({}),
+		cardId: belongsTo({}).type(),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/AutoFinishedTimeTrackingSegment.ts
+const autoFinishedTimeTrackingSegmentDesc = makeModel({
+	name: "autoFinishedTimeTrackingSegment",
+	fields: {
+		createdAt: date({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		timeTrackingSegmentId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		timeTrackingSegment: relation("timeTrackingSegment", {
+			type: "belongsTo",
+			fk: "timeTrackingSegmentId"
+		})
+	},
+	keys: ["userId", "accountId"]
+});
+
+//#endregion
+//#region src/models/CardDiffNotification.ts
+const cardDiffNotificationDesc = makeModel({
+	name: "cardDiffNotification",
+	fields: {
+		changes: object({}),
+		asOwner: bool({}),
+		changers: array({}),
+		lastUpdatedAt: date({}),
+		createdAt: date({}),
+		userId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["userId", "cardId"]
+});
+
+//#endregion
+//#region src/models/CardHistory.ts
+const cardHistoryDesc = makeModel({
+	name: "cardHistory",
+	fields: {
+		diff: object({}),
+		versionCreatedAt: date({}),
+		version: int({}),
+		accountId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		changerId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		changer: relation("user", {
+			type: "belongsTo",
+			fk: "changerId"
+		})
+	},
+	keys: ["cardId", "version"]
+});
+
+//#endregion
+//#region src/models/CardOrderInDeck.ts
+const cardOrderInDeckDesc = makeModel({
+	name: "cardOrderInDeck",
+	fields: {
+		sortIndex: string({}),
+		cardId: belongsTo({}).type(),
+		deckId: belongsTo({}).type(),
+		changerId: belongsTo({}).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId"
+		}),
+		changer: relation("user", {
+			type: "belongsTo",
+			fk: "changerId"
+		})
+	},
+	keys: ["cardId", "deckId"]
+});
+
+//#endregion
+//#region src/models/CardOrder.ts
+const cardOrderDesc = makeModel({
+	name: "cardOrder",
+	fields: {
+		sortValue: string({}),
+		label: string({}),
+		cardId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["context", "cardId"]
+});
+
+//#endregion
+//#region src/models/CardPreset.ts
+const cardPresetDesc = makeModel({
+	name: "cardPreset",
+	fields: {
+		id: id(),
+		name: string({}),
+		data: object({}),
+		createdAt: date({}),
+		accountId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/CardSubscription.ts
+const cardSubscriptionDesc = makeModel({
+	name: "cardSubscription",
+	fields: {
+		id: id(),
+		createdAt: date({}),
+		userId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/CardUpvote.ts
+const cardUpvoteDesc = makeModel({
+	name: "cardUpvote",
+	fields: {
+		id: id(),
+		type: string({}),
+		createdAt: date({}),
+		discordUserInfo: object({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		cardId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/CardsEffortHistory.ts
+const cardsEffortHistoryDesc = makeModel({
+	name: "cardsEffortHistory",
+	fields: {
+		effortSum: bigint({}),
+		cardCount: bigint({}),
+		date: day({})
+	},
+	relations: {},
+	keys: [
+		"date",
+		"effortSum",
+		"cardCount"
+	]
+});
+
+//#endregion
+//#region src/models/CardsFinishedHistory.ts
+const cardsFinishedHistoryDesc = makeModel({
+	name: "cardsFinishedHistory",
+	fields: {
+		effortSum: bigint({}),
+		cardCount: bigint({}),
+		date: day({}),
+		assigneeId: belongsTo({}).type()
+	},
+	relations: { assignee: relation("user", {
+		type: "belongsTo",
+		fk: "assigneeId"
+	}) },
+	keys: [
+		"date",
+		"effortSum",
+		"cardCount",
+		"assigneeId"
+	]
+});
+
+//#endregion
+//#region src/models/CardsStatusHistory.ts
+const cardsStatusHistoryDesc = makeModel({
+	name: "cardsStatusHistory",
+	fields: {
+		status: string({}),
+		count: int({}),
+		date: day({})
+	},
+	relations: {},
+	keys: [
+		"date",
+		"status",
+		"count"
+	]
+});
+
+//#endregion
+//#region src/models/CardsTimeToFinished.ts
+const cardsTimeToFinishedDesc = makeModel({
+	name: "cardsTimeToFinished",
+	fields: {
+		effort: int({}),
+		startedAt: date({}),
+		doneAt: date({}),
+		cardId: belongsTo({}).type(),
+		assigneeId: belongsTo({}).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		assignee: relation("user", {
+			type: "belongsTo",
+			fk: "assigneeId"
+		})
+	},
+	keys: [
+		"cardId",
+		"startedAt",
+		"doneAt",
+		"effort",
+		"assigneeId"
+	]
+});
+
+//#endregion
+//#region src/models/DailyDiscordGuildVoteMembership.ts
+const dailyDiscordGuildVoteMembershipDesc = makeModel({
+	name: "dailyDiscordGuildVoteMembership",
+	fields: {
+		t: date({}),
+		membershipCount: int({}),
+		discordGuildId: belongsTo({}).type()
+	},
+	relations: { discordGuild: relation("discordGuild", {
+		type: "belongsTo",
+		fk: "discordGuildId"
+	}) },
+	keys: ["t", "guildId"]
+});
+
+//#endregion
+//#region src/models/DailyPublicProjectMembership.ts
+const dailyPublicProjectMembershipDesc = makeModel({
+	name: "dailyPublicProjectMembership",
+	fields: {
+		t: date({}),
+		membershipCount: int({}),
+		projectId: belongsTo({}).type()
+	},
+	relations: { project: relation("project", {
+		type: "belongsTo",
+		fk: "projectId"
+	}) },
+	keys: ["t", "projectId"]
+});
+
+//#endregion
+//#region src/models/PublicProjectVisit.ts
+const publicProjectVisitDesc = makeModel({
+	name: "publicProjectVisit",
+	fields: {
+		t: date({}),
+		topReferrers: object({}),
+		visitCounts: int({}),
+		projectId: belongsTo({}).type()
+	},
+	relations: { project: relation("project", {
+		type: "belongsTo",
+		fk: "projectId"
+	}) },
+	keys: ["t", "projectId"]
+});
+
+//#endregion
+//#region src/models/DeckAssignment.ts
+const deckAssignmentDesc = makeModel({
+	name: "deckAssignment",
+	fields: {
+		lastAssignedAt: date({}),
+		deckId: belongsTo({}).type(),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["userId", "deckId"]
+});
+
+//#endregion
+//#region src/models/DeckGuardian.ts
+const deckGuardianDesc = makeModel({
+	name: "deckGuardian",
+	fields: {
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		deckId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId"
+		})
+	},
+	keys: ["deckId", "userId"]
+});
+
+//#endregion
+//#region src/models/DeckSubscription.ts
+const deckSubscriptionDesc = makeModel({
+	name: "deckSubscription",
+	fields: {
+		id: id(),
+		userId: belongsTo({}).type(),
+		deckId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/DiscordMember.ts
+const discordMemberDesc = makeModel({
+	name: "discordMember",
+	fields: {
+		id: id(),
+		discordUserId: string({}),
+		name: string({}),
+		nick: string({}),
+		avatar: string({}),
+		discriminator: string({}),
+		createdAt: date({}),
+		deckyScore: int({}),
+		discordGuildId: belongsTo({}).type()
+	},
+	relations: { discordGuild: relation("discordGuild", {
+		type: "belongsTo",
+		fk: "discordGuildId"
+	}) },
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/DiscordProjectNotification.ts
+const discordProjectNotificationDesc = makeModel({
+	name: "discordProjectNotification",
+	fields: {
+		id: id(),
+		discordChannelId: string({}),
+		disabledTypes: object({}),
+		createdAt: date({}),
+		projectId: belongsTo({}).type(),
+		discordGuildId: belongsTo({}).type()
+	},
+	relations: {
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		discordGuild: relation("discordGuild", {
+			type: "belongsTo",
+			fk: "discordGuildId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/DiscordSlashCommand.ts
+const discordSlashCommandDesc = makeModel({
+	name: "discordSlashCommand",
+	fields: {
+		id: id(),
+		channelId: string({}),
+		statusTargetChannelId: string({}),
+		reaction: string({}),
+		name: string({}),
+		description: string({}),
+		autoAddRoleToThread: string({}),
+		leaderboard: object({}),
+		reactionThreshold: int({}),
+		karmaForCompletion: int({}),
+		maxFileSizeInBytes: int({}),
+		statusMessages: object({}),
+		permissions: object({}),
+		deckId: belongsTo({}).type(),
+		discordGuildId: belongsTo({}).type()
+	},
+	relations: {
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId"
+		}),
+		discordGuild: relation("discordGuild", {
+			type: "belongsTo",
+			fk: "discordGuildId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/DueCard.ts
+const dueCardDesc = makeModel({
+	name: "dueCard",
+	fields: {
+		createdAt: date({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		cardId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		})
+	},
+	keys: ["userId", "cardId"]
+});
+
+//#endregion
+//#region src/models/HandCard.ts
+const handCardDesc = makeModel({
+	name: "handCard",
+	fields: {
+		sortIndex: int({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		cardId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		})
+	},
+	keys: [
+		"cardId",
+		"userId",
+		"accountId"
+	]
+});
+
+//#endregion
+//#region src/models/Integration.ts
+const integrationDesc = makeModel({
+	name: "integration",
+	fields: {
+		id: id(),
+		type: string({}),
+		disabled: string({}),
+		userData: object({}),
+		createdAt: date({}),
+		version: int({}),
+		accountId: belongsTo({}).type(),
+		userId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Invoice.ts
+const invoiceDesc = makeModel({
+	name: "invoice",
+	fields: {
+		id: id(),
+		invoiceNumber: string({}),
+		url: string({}),
+		createdAt: date({}),
+		total: int({}),
+		subtotal: int({}),
+		charged: int({}),
+		chargeData: object({}),
+		accountId: belongsTo({}).type()
+	},
+	relations: { account: relation("account", {
+		type: "belongsTo",
+		fk: "accountId"
+	}) },
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/LastSeenCardUpvote.ts
+const lastSeenCardUpvoteDesc = makeModel({
+	name: "lastSeenCardUpvote",
+	fields: {
+		lastSeenAt: date({}),
+		createdAt: date({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["userId", "accountId"]
+});
+
+//#endregion
+//#region src/models/MilestoneProgress.ts
+const milestoneProgressDesc = makeModel({
+	name: "milestoneProgress",
+	fields: {
+		progress: object({}),
+		milestoneId: belongsTo({}).type()
+	},
+	relations: { milestone: relation("milestone", {
+		type: "belongsTo",
+		fk: "milestoneId"
+	}) },
+	keys: ["milestoneId", "date"]
+});
+
+//#endregion
+//#region src/models/MilestoneProject.ts
+const milestoneProjectDesc = makeModel({
+	name: "milestoneProject",
+	fields: {
+		milestoneId: belongsTo({}).type(),
+		projectId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		milestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "milestoneId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["milestoneId", "projectId"]
+});
+
+//#endregion
+//#region src/models/PinnedMilestone.ts
+const pinnedMilestoneDesc = makeModel({
+	name: "pinnedMilestone",
+	fields: {
+		id: id(),
+		autoAssignStartedCard: bool({}),
+		autoAssignNewCard: bool({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		sprintId: belongsTo({}).type(),
+		milestoneId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		sprint: relation("sprint", {
+			type: "belongsTo",
+			fk: "sprintId"
+		}),
+		milestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "milestoneId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/ProjectOrder.ts
+const projectOrderDesc = makeModel({
+	name: "projectOrder",
+	fields: {
+		sortIndex: int({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		projectId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		})
+	},
+	keys: [
+		"projectId",
+		"userId",
+		"accountId"
+	]
+});
+
+//#endregion
+//#region src/models/ProjectSelection.ts
+const projectSelectionDesc = makeModel({
+	name: "projectSelection",
+	fields: {
+		id: id(),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		projectId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/ProjectUserSetting.ts
+const projectUserSettingDesc = makeModel({
+	name: "projectUserSetting",
+	fields: {
+		projectId: belongsTo({}).type(),
+		userId: belongsTo({}).type()
+	},
+	relations: {
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		})
+	},
+	keys: ["projectId", "userId"]
+});
+
+//#endregion
+//#region src/models/ProjectUser.ts
+const projectUserDesc = makeModel({
+	name: "projectUser",
+	fields: {
+		projectRole: string({}),
+		userId: belongsTo({}).type(),
+		projectId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["projectId", "userId"]
+});
+
+//#endregion
+//#region src/models/PublicProjectInfo.ts
+const publicProjectInfoDesc = makeModel({
+	name: "publicProjectInfo",
+	fields: {
+		lastActivityAt: string({}),
+		activities7d: string({}),
+		cardCount: string({}),
+		visits7d: string({}),
+		cardDoneStreak: string({}),
+		projectId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["projectId"]
+});
+
+//#endregion
+//#region src/models/PublicProjectMembership.ts
+const publicProjectMembershipDesc = makeModel({
+	name: "publicProjectMembership",
+	fields: {
+		digestFrequencyInDays: int({}),
+		createdAt: date({}),
+		userId: belongsTo({}).type(),
+		projectId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		})
+	},
+	keys: ["userId", "projectId"]
+});
+
+//#endregion
+//#region src/models/QueueEntry.ts
+const queueEntryDesc = makeModel({
+	name: "queueEntry",
+	fields: {
+		id: id(),
+		sortIndex: int({}),
+		cardDoneAt: date({}),
+		createdAt: date({}),
+		accountId: belongsTo({}).type(),
+		userId: belongsTo({}).type(),
+		cardId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/QueueSelection.ts
+const queueSelectionDesc = makeModel({
+	name: "queueSelection",
+	fields: {
+		id: id(),
+		sortIndex: int({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		queueUserId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		queueUser: relation("user", {
+			type: "belongsTo",
+			fk: "queueUserId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Resolvable.ts
+const resolvableDesc = makeModel({
+	name: "resolvable",
+	fields: {
+		id: id(),
+		context: string({}),
+		contextAsPrio: int({}),
+		isClosed: bool({}),
+		closedAt: date({ optional: true }),
+		createdAt: date({}),
+		isPublic: bool({}),
+		cardId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type(),
+		closedById: belongsTo({ optional: true }).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		closedBy: relation("user", {
+			type: "belongsTo",
+			fk: "closedById"
+		}),
+		participants: relation("resolvableParticipant", { type: "hasMany" }),
+		participantHistories: relation("resolvableParticipantHistory", { type: "hasMany" }),
+		entries: relation("resolvableEntry", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/ResolvableEntry.ts
+const resolvableEntryDesc = makeModel({
+	name: "resolvableEntry",
+	fields: {
+		entryId: id(),
+		content: string({}),
+		lastChangedAt: date({}),
+		createdAt: date({}),
+		version: int({}),
+		meta: object({}),
+		resolvableId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		authorId: belongsTo({}).type()
+	},
+	relations: {
+		resolvable: relation("resolvable", {
+			type: "belongsTo",
+			fk: "resolvableId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		author: relation("user", {
+			type: "belongsTo",
+			fk: "authorId"
+		}),
+		reactions: relation("resolvableEntryReaction", { type: "hasMany" }),
+		histories: relation("resolvableEntryHistory", { type: "hasMany" })
+	},
+	keys: ["entryId"]
+});
+
+//#endregion
+//#region src/models/ResolvableEntryHistory.ts
+const resolvableEntryHistoryDesc = makeModel({
+	name: "resolvableEntryHistory",
+	fields: {
+		content: string({}),
+		lastChangedAt: date({}),
+		version: int({}),
+		resolvableId: belongsTo({}).type(),
+		authorId: belongsTo({}).type(),
+		entryId: belongsTo({}).type()
+	},
+	relations: {
+		resolvable: relation("resolvable", {
+			type: "belongsTo",
+			fk: "resolvableId"
+		}),
+		author: relation("user", {
+			type: "belongsTo",
+			fk: "authorId"
+		}),
+		entry: relation("resolvableEntry", {
+			type: "belongsTo",
+			fk: "entryId"
+		})
+	},
+	keys: ["entryId", "version"]
+});
+
+//#endregion
+//#region src/models/ResolvableEntryReaction.ts
+const resolvableEntryReactionDesc = makeModel({
+	name: "resolvableEntryReaction",
+	fields: {
+		id: id(),
+		value: object({}),
+		createdAt: date({}),
+		isPublic: bool({}),
+		resolvableEntryId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		userId: belongsTo({}).type(),
+		resolvableId: belongsTo({}).type()
+	},
+	relations: {
+		resolvableEntry: relation("resolvableEntry", {
+			type: "belongsTo",
+			fk: "resolvableEntryId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		resolvable: relation("resolvable", {
+			type: "belongsTo",
+			fk: "resolvableId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/ResolvableNotification.ts
+const resolvableNotificationDesc = makeModel({
+	name: "resolvableNotification",
+	fields: {
+		isParticipating: bool({}),
+		isSnoozing: bool({}),
+		unseenEntryCount: int({}),
+		unseenAuthors: array({}),
+		isLastParticipant: bool({}),
+		lastUpdatedAt: date({}),
+		snoozeUntil: date({ optional: true }),
+		remindMeOn: date({ optional: true }),
+		createdAt: date({}),
+		userId: belongsTo({}).type(),
+		resolvableId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		latestEntryId: belongsTo({}).type(),
+		latestSeenEntryId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		resolvable: relation("resolvable", {
+			type: "belongsTo",
+			fk: "resolvableId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		latestEntry: relation("resolvableEntry", {
+			type: "belongsTo",
+			fk: "latestEntryId"
+		}),
+		latestSeenEntry: relation("resolvableEntry", {
+			type: "belongsTo",
+			fk: "latestSeenEntryId"
+		})
+	},
+	keys: ["userId", "resolvableId"]
+});
+
+//#endregion
+//#region src/models/ResolvableParticipantHistory.ts
+const resolvableParticipantHistoryDesc = makeModel({
+	name: "resolvableParticipantHistory",
+	fields: {
+		firstJoinedAt: string({}),
+		done: string({}),
+		status: string({}),
+		lastChangedAt: date({}),
+		version: int({}),
+		reaction: string({}),
+		resolvableId: belongsTo({}).type(),
+		userId: belongsTo({}).type(),
+		addedById: belongsTo({}).type()
+	},
+	relations: {
+		resolvable: relation("resolvable", {
+			type: "belongsTo",
+			fk: "resolvableId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		addedBy: relation("user", {
+			type: "belongsTo",
+			fk: "addedById"
+		})
+	},
+	keys: [
+		"participantId",
+		"resolvableId",
+		"version"
+	]
+});
+
+//#endregion
+//#region src/models/ResolvableParticipant.ts
+const resolvableParticipantDesc = makeModel({
+	name: "resolvableParticipant",
+	fields: {
+		firstJoinedAt: date({}),
+		lastChangedAt: date({}),
+		done: bool({}),
+		status: string({}),
+		discordUserId: string({}),
+		resolvableIsClosed: bool({}),
+		resolvableId: belongsTo({}).type(),
+		accountId: belongsTo({}).type(),
+		userId: belongsTo({}).type(),
+		addedById: belongsTo({}).type()
+	},
+	relations: {
+		resolvable: relation("resolvable", {
+			type: "belongsTo",
+			fk: "resolvableId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		addedBy: relation("user", {
+			type: "belongsTo",
+			fk: "addedById"
+		})
+	},
+	keys: ["participantId", "resolvableId"]
+});
+
+//#endregion
+//#region src/models/SavedSearch.ts
+const savedSearchDesc = makeModel({
+	name: "savedSearch",
+	fields: {
+		id: id(),
+		tokens: array({}),
+		forceOr: bool({}),
+		accountId: belongsTo({}).type(),
+		ownerId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		owner: relation("user", {
+			type: "belongsTo",
+			fk: "ownerId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/SprintConfigProgress.ts
+const sprintConfigProgressDesc = makeModel({
+	name: "sprintConfigProgress",
+	fields: {
+		progress: object({}),
+		sprintConfigId: belongsTo({}).type()
+	},
+	relations: { sprintConfig: relation("sprintConfig", {
+		type: "belongsTo",
+		fk: "sprintConfigId"
+	}) },
+	keys: ["sprintConfigId", "date"]
+});
+
+//#endregion
+//#region src/models/SprintProgress.ts
+const sprintProgressDesc = makeModel({
+	name: "sprintProgress",
+	fields: {
+		progress: object({}),
+		sprintId: belongsTo({}).type()
+	},
+	relations: { sprint: relation("sprint", {
+		type: "belongsTo",
+		fk: "sprintId"
+	}) },
+	keys: ["sprintId", "date"]
+});
+
+//#endregion
+//#region src/models/SprintProject.ts
+const sprintProjectDesc = makeModel({
+	name: "sprintProject",
+	fields: {
+		sprintConfigId: belongsTo({}).type(),
+		projectId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		sprintConfig: relation("sprintConfig", {
+			type: "belongsTo",
+			fk: "sprintConfigId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["sprintConfigId", "projectId"]
+});
+
+//#endregion
+//#region src/models/StripeAccountSync.ts
+const stripeAccountSyncDesc = makeModel({
+	name: "stripeAccountSync",
+	fields: {
+		status: string({}),
+		euVatIdData: object({}),
+		vatCountryCode: string({}),
+		vatTaxPercentage: int({}),
+		centsPerSeat: int({}),
+		billingCycleStart: date({}),
+		billingCycleEnd: date({}),
+		grossActualBalance: int({}),
+		grossBonusBalance: int({}),
+		netGiftBalance: int({}),
+		paymentMethod: object({}),
+		hasBeenCancelledAt: date({}),
+		planType: string({}),
+		planName: string({}),
+		pendingPlanType: string({}),
+		repeatingCoupon: object({}),
+		accountId: belongsTo({}).type()
+	},
+	relations: { account: relation("account", {
+		type: "belongsTo",
+		fk: "accountId"
+	}) },
+	keys: ["accountId"]
+});
+
+//#endregion
+//#region src/models/TimeTrackingSum.ts
+const timeTrackingSumDesc = makeModel({
+	name: "timeTrackingSum",
+	fields: {
+		sumMs: int({}),
+		runningStartedAt: date({}),
+		runningModifyDurationMsBy: int({}),
+		cardId: belongsTo({}).type(),
+		userId: belongsTo({}).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		})
+	},
+	keys: ["cardId", "userId"]
+});
+
+//#endregion
+//#region src/models/UserDismissedHint.ts
+const userDismissedHintDesc = makeModel({
+	name: "userDismissedHint",
+	fields: {
+		hintKey: string({}),
+		createdAt: date({}),
+		returnAt: date({}),
+		userId: belongsTo({}).type()
+	},
+	relations: { user: relation("user", {
+		type: "belongsTo",
+		fk: "userId"
+	}) },
+	keys: ["userId", "hintKey"]
+});
+
+//#endregion
+//#region src/models/UserEmail.ts
+const userEmailDesc = makeModel({
+	name: "userEmail",
+	fields: {
+		id: id(),
+		email: string({}),
+		createdAt: date({}),
+		isPrimary: bool({}),
+		isVerified: bool({}),
+		userId: belongsTo({}).type()
+	},
+	relations: { user: relation("user", {
+		type: "belongsTo",
+		fk: "userId"
+	}) },
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/UserInvitation.ts
+const userInvitationDesc = makeModel({
+	name: "userInvitation",
+	fields: {
+		id: id(),
+		email: string({}),
+		role: string({}),
+		accessToProjectIds: array({}),
+		createdAt: date({}),
+		accountId: belongsTo({}).type(),
+		inviterId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		inviter: relation("user", {
+			type: "belongsTo",
+			fk: "inviterId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/UserInviteCode.ts
+const userInviteCodeDesc = makeModel({
+	name: "userInviteCode",
+	fields: {
+		id: id(),
+		token: string({}),
+		role: string({}),
+		useCount: string({}),
+		isActive: string({}),
+		accessToProjectIds: array({}),
+		validUntil: date({}),
+		createdAt: date({}),
+		accountId: belongsTo({}).type(),
+		creatorId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/UserOnboarding.ts
+const userOnboardingDesc = makeModel({
+	name: "userOnboarding",
+	fields: {
+		steps: object({}),
+		userId: belongsTo({}).type()
+	},
+	relations: { user: relation("user", {
+		type: "belongsTo",
+		fk: "userId"
+	}) },
+	keys: ["userId"]
+});
+
+//#endregion
+//#region src/models/UserProjectAccess.ts
+const userProjectAccessDesc = makeModel({
+	name: "userProjectAccess",
+	fields: {
+		role: string({}),
+		projectRole: string({}),
+		userId: belongsTo({}).type(),
+		projectId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		})
+	},
+	keys: ["projectId", "userId"]
+});
+
+//#endregion
+//#region src/models/UserTag.ts
+const userTagDesc = makeModel({
+	name: "userTag",
+	fields: {
+		id: id(),
+		tag: string({}),
+		createdAt: date({}),
+		userId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/UserReportSetting.ts
+const userReportSettingDesc = makeModel({
+	name: "userReportSetting",
+	fields: {
+		id: id(),
+		name: string({}),
+		fileSizeBytesLimit: bigint({}),
+		createdAt: date({}),
+		deckMapping: object({}),
+		prioMapping: object({}),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		reportTokens: relation("userReportToken", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/UserReportEmail.ts
+const userReportEmailDesc = makeModel({
+	name: "userReportEmail",
+	fields: {
+		id: id(),
+		email: string({}),
+		createdAt: date({}),
+		enabled: string({}),
+		userReportSettingId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		userReportSetting: relation("userReportSetting", {
+			type: "belongsTo",
+			fk: "userReportSettingId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/UserReportToken.ts
+const userReportTokenDesc = makeModel({
+	name: "userReportToken",
+	fields: {
+		token: id(),
+		label: string({}),
+		reportCount: int({}),
+		createdAt: date({}),
+		enabled: string({}),
+		userReportSettingId: belongsTo({}).type()
+	},
+	relations: { userReportSetting: relation("userReportSetting", {
+		type: "belongsTo",
+		fk: "userReportSettingId"
+	}) },
+	keys: ["token"]
+});
+
+//#endregion
+//#region src/models/VisionBoardQuery.ts
+const visionBoardQueryDesc = makeModel({
+	name: "visionBoardQuery",
+	fields: {
+		id: id(),
+		query: object({}),
+		lastUsedAt: date({}),
+		isStale: bool({}),
+		type: string({}),
+		payload: object({}),
+		createdAt: date({}),
+		cardId: belongsTo({}).type(),
+		accountId: belongsTo({}).type()
+	},
+	relations: {
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Wizard.ts
+const wizardDesc = makeModel({
+	name: "wizard",
+	fields: {
+		id: id(),
+		name: string({}),
+		currentStep: string({}),
+		data: object({}),
+		createdAt: date({}),
+		finishedAt: date({}),
+		accountId: belongsTo({}).type()
+	},
+	relations: { account: relation("account", {
+		type: "belongsTo",
+		fk: "accountId"
+	}) },
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/WorkflowItemHistory.ts
+const workflowItemHistoryDesc = makeModel({
+	name: "workflowItemHistory",
+	fields: {
+		diff: object({}),
+		versionCreatedAt: date({}),
+		version: int({}),
+		accountId: belongsTo({}).type(),
+		changerId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		changer: relation("user", {
+			type: "belongsTo",
+			fk: "changerId"
+		})
+	},
+	keys: ["itemId", "version"]
+});
+
+//#endregion
+//#region src/models/index.ts
+const modelMap = {
+	_root: _rootDesc,
+	accountOnboardingStep: accountOnboardingStepDesc,
+	accountOnboarding: accountOnboardingDesc,
+	accountRole: accountRoleDesc,
+	accountUserAchievement: accountUserAchievementDesc,
+	accountUserSetting: accountUserSettingDesc,
+	account: accountDesc,
+	activeTimeTracker: activeTimeTrackerDesc,
+	activity: activityDesc,
+	affiliateCodeStat: affiliateCodeStatDesc,
+	affiliateCode: affiliateCodeDesc,
+	appInstallation: appInstallationDesc,
+	app: appDesc,
+	assigneeAssignment: assigneeAssignmentDesc,
+	assigneeDeckAssignment: assigneeDeckAssignmentDesc,
+	attachment: attachmentDesc,
+	autoFinishedTimeTrackingSegment: autoFinishedTimeTrackingSegmentDesc,
+	cardDiffNotification: cardDiffNotificationDesc,
+	cardHistory: cardHistoryDesc,
+	cardOrderInDeck: cardOrderInDeckDesc,
+	cardOrder: cardOrderDesc,
+	cardPreset: cardPresetDesc,
+	cardSubscription: cardSubscriptionDesc,
+	cardUpvote: cardUpvoteDesc,
+	card: cardDesc,
+	cardsEffortHistory: cardsEffortHistoryDesc,
+	cardsFinishedHistory: cardsFinishedHistoryDesc,
+	cardsStatusHistory: cardsStatusHistoryDesc,
+	cardsTimeToFinished: cardsTimeToFinishedDesc,
+	dailyDiscordGuildVoteMembership: dailyDiscordGuildVoteMembershipDesc,
+	dailyPublicProjectMembership: dailyPublicProjectMembershipDesc,
+	publicProjectVisit: publicProjectVisitDesc,
+	deckAssignment: deckAssignmentDesc,
+	deckGuardian: deckGuardianDesc,
+	deckSubscription: deckSubscriptionDesc,
+	deck: deckDesc,
+	discordGuild: discordGuildDesc,
+	discordMember: discordMemberDesc,
+	discordProjectNotification: discordProjectNotificationDesc,
+	discordSlashCommand: discordSlashCommandDesc,
+	dueCard: dueCardDesc,
+	file: fileDesc,
+	handCard: handCardDesc,
+	integration: integrationDesc,
+	invoice: invoiceDesc,
+	lastSeenCardUpvote: lastSeenCardUpvoteDesc,
+	milestoneProgress: milestoneProgressDesc,
+	milestoneProject: milestoneProjectDesc,
+	milestone: milestoneDesc,
+	pinnedMilestone: pinnedMilestoneDesc,
+	projectOrder: projectOrderDesc,
+	projectSelection: projectSelectionDesc,
+	projectTag: projectTagDesc,
+	projectUserSetting: projectUserSettingDesc,
+	projectUser: projectUserDesc,
+	project: projectDesc,
+	publicProjectInfo: publicProjectInfoDesc,
+	publicProjectMembership: publicProjectMembershipDesc,
+	queueEntry: queueEntryDesc,
+	queueSelection: queueSelectionDesc,
+	release: releaseDesc,
+	resolvableEntryHistory: resolvableEntryHistoryDesc,
+	resolvableEntryReaction: resolvableEntryReactionDesc,
+	resolvableEntry: resolvableEntryDesc,
+	resolvableNotification: resolvableNotificationDesc,
+	resolvableParticipantHistory: resolvableParticipantHistoryDesc,
+	resolvableParticipant: resolvableParticipantDesc,
+	resolvable: resolvableDesc,
+	savedSearch: savedSearchDesc,
+	sprintConfigProgress: sprintConfigProgressDesc,
+	sprintConfig: sprintConfigDesc,
+	sprintProgress: sprintProgressDesc,
+	sprintProject: sprintProjectDesc,
+	sprint: sprintDesc,
+	stripeAccountSync: stripeAccountSyncDesc,
+	timeTrackingSegment: timeTrackingSegmentDesc,
+	timeTrackingSum: timeTrackingSumDesc,
+	userDismissedHint: userDismissedHintDesc,
+	userEmail: userEmailDesc,
+	userInvitation: userInvitationDesc,
+	userInviteCode: userInviteCodeDesc,
+	userOnboarding: userOnboardingDesc,
+	userProjectAccess: userProjectAccessDesc,
+	userTag: userTagDesc,
+	user: userDesc,
+	userReportEmail: userReportEmailDesc,
+	userReportSetting: userReportSettingDesc,
+	userReportToken: userReportTokenDesc,
+	visionBoardQuery: visionBoardQueryDesc,
+	visionBoard: visionBoardDesc,
+	wizard: wizardDesc,
+	workflowItemHistory: workflowItemHistoryDesc,
+	workflowItem: workflowItemDesc
+};
+
+//#endregion
+//#region src/query-helpers.ts
+const getRelKey = (r, k) => {
+	const isPlainKey = () => {
+		if (r.type === "first") return false;
+		if (r.filter && Object.keys(r.filter).length > 0) return false;
+		if (r.type === "query" || r.type === void 0) {
+			if (r.limit || r.orderBy || r.offset) return false;
+		}
+		return true;
+	};
+	if (isPlainKey()) return k;
+	const q = { ...r.filter };
+	if (r.type === "first") {
+		q.$first = true;
+		q.$order = r.orderBy;
+	}
+	if (r.type === "query" || r.type === void 0) {
+		if (r.limit) q.$limit = r.limit;
+		if (r.offset) q.$offset = r.offset;
+		if (r.orderBy) q.$order = r.orderBy;
+	}
+	return `${k}(${JSON.stringify(q)})`;
+};
+const serializeModel = (q, modelDesc) => {
+	const list = q.fields ? [...q.fields] : [];
+	if (!q.relations) return list;
+	const relObj = {};
+	Object.entries(q.relations).forEach(([k, _v]) => {
+		const rels = Array.isArray(_v) ? _v : [_v];
+		rels.forEach((r) => {
+			switch (r?.type) {
+				case "count": {
+					list.push(`count(${getRelKey(r, k)})`);
+					break;
+				}
+				case "exists": {
+					list.push(`exists(${getRelKey(r, k)})`);
+					break;
+				}
+				default:
+					relObj[getRelKey(r, k)] = serializeModel(r, modelDesc);
+					break;
+			}
+		});
+	});
+	if (Object.keys(relObj).length) list.push(relObj);
+	return list;
+};
+const serializeRelations = (q, modelDesc) => {
+	return Object.fromEntries(Object.entries(q).map(([k, v]) => [k, serializeModel(v, modelDesc.relations[k])]));
+};
+const serializeRootQuery = (q) => {
+	return { _root: serializeRelations(q, _rootDesc) };
+};
+const serializeInstanceQuery = (q, instances, modelMap$1) => {
+	return Object.fromEntries(instances.map((instance) => {
+		const name = instance["~model"];
+		return [`${name}(${instance["~key"]})`, serializeModel(q, modelMap$1[name])];
+	}));
+};
+
+//#endregion
+//#region src/reconcile-query.ts
+const reconcileRootQuery = (query, response, pool) => {
+	const result = {};
+	const responsePart = response._root;
+	for (const [relName, modelFields] of Object.entries(query)) {
+		const relDesc = _rootDesc.relations[relName];
+		const id$1 = responsePart[relName];
+		if (!id$1) {
+			result[relName] = null;
+			continue;
+		} else result[relName] = reconcileInstanceQuery(modelFields, response, modelMap[relDesc.relName], `${id$1}`, pool);
+	}
+	return result;
+};
+const reconcileInstanceQuery = (query, response, instanceModel, key, pool) => {
+	const instance = pool.get(instanceModel.name, key);
+	if (!instance) {
+		console.warn(`no instance found in pool: [${instanceModel.name}, ${key}]`);
+		return null;
+	}
+	const result = {
+		"~model": instanceModel.name,
+		"~key": key
+	};
+	instanceModel.keys.map((k) => result[k] = instance[k]);
+	for (const field of query.fields || []) result[field] = instance[field];
+	for (const [relName, _relEntries] of Object.entries(query.relations || {})) {
+		const relEntryList = Array.isArray(_relEntries) ? _relEntries : [_relEntries];
+		for (const relEntry of relEntryList) {
+			const relDesc = instanceModel.relations[relName];
+			if (!relDesc) throw new Error(`Can't find relation ${relName} in ${instanceModel.name}`);
+			const opts = relDesc.options;
+			const relModel = modelMap[relDesc.relName];
+			switch (opts.type) {
+				case "belongsTo":
+					result[opts.fk] = instance[relName];
+					result[relName] = opts.fk ? reconcileInstanceQuery(relEntry, response, relModel, `${instance[relName]}`, pool) : null;
+					break;
+				case "hasOne":
+					result[`~${relName}`] = instance[relName];
+					result[relName] = reconcileInstanceQuery(relEntry, response, relModel, `${instance[relName]}`, pool);
+					break;
+				case "hasMany":
+					const asName = relEntry.as ?? relName;
+					const relKey = getRelKey(relEntry, relName);
+					const val = instance[relKey];
+					switch (relEntry.type) {
+						case "count": {
+							result[asName] = instance[`count(${relKey})`];
+							break;
+						}
+						case "exists": {
+							result[asName] = instance[`exists(${relKey})`];
+							break;
+						}
+						case "first":
+							result[`~${asName}`] = val;
+							result[asName] = reconcileInstanceQuery(relEntry, response, relModel, `${val}`, pool);
+							break;
+						default: {
+							result[`~${asName}`] = val;
+							result[asName] = val.map((id$1) => reconcileInstanceQuery(relEntry, response, relModel, `${id$1}`, pool));
+						}
+					}
+					break;
+			}
+		}
+	}
+	return result;
+};
+
+//#endregion
+//#region src/index.ts
+const buildFetchers = (opts = {}) => {
+	const fetchImpl = opts.fetch || globalThis.fetch;
+	const configuredFetch = async (url, init = {}) => {
+		const headers = new Headers(init.headers);
+		if (opts.accessToken) headers.set("X-Auth-Token", opts.accessToken);
+		if (opts.subdomain) headers.set("X-Account", opts.subdomain);
+		if (opts.headers) Object.entries(opts.headers).forEach(([key, value]) => {
+			headers.set(key, value);
+		});
+		const fullUrl = opts.baseUrl ? `${opts.baseUrl}${url}` : url;
+		return fetchImpl(fullUrl, {
+			...init,
+			headers
+		});
+	};
+	const fetchWithQuery = async (query) => {
+		const response = await configuredFetch("", {
+			method: "POST",
+			body: JSON.stringify({ query: JSON.stringify(query) })
+		}).then(async (r) => {
+			const content = await r.json();
+			if (r.status !== 200) throw new Error(`[${r.status}] ${JSON.stringify(content)}`);
+			return content;
+		});
+		return response;
+	};
+	const _fetchSingleInstance = async (instance, q) => {
+		const response = await fetchWithQuery(serializeInstanceQuery(q, [instance], modelMap));
+		const pool = new ModelPool(modelMap);
+		pool.add(response);
+		return reconcileInstanceQuery(q, response, modelMap[instance["~model"]], instance["~key"], pool);
+	};
+	return {
+		fetchFromRoot: async (q) => {
+			const response = await fetchWithQuery(serializeRootQuery(q));
+			const pool = new ModelPool(modelMap);
+			pool.add(response);
+			return reconcileRootQuery(q, response, pool);
+		},
+		fetchFromInstance: _fetchSingleInstance,
+		fetchInstance: async (key, id$1, q) => {
+			const instance = {
+				"~model": key,
+				"~key": id$1
+			};
+			return _fetchSingleInstance(instance, q);
+		},
+		fetchInstances: async (key, ids, q) => {
+			const modelDesc = modelMap[key];
+			const instances = ids.map((id$1) => ({
+				"~model": key,
+				"~key": id$1
+			}));
+			const response = await fetchWithQuery(serializeInstanceQuery(q, instances, modelMap));
+			const pool = new ModelPool(modelMap);
+			pool.add(response);
+			return Object.fromEntries(ids.map((id$1) => [id$1, reconcileInstanceQuery(q, response, modelDesc, id$1, pool)]));
+		}
+	};
+};
+
+//#endregion
+export { buildFetchers };