@codecks/fetch 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,2988 +1,6 @@
-//#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/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"]
-});
+import { configuredFetch, ensureMapValue } from "./collection-utils-CYJaA1a9.js";
+import { _rootDesc, getRelKey, makeModelQuerySerializable, modelMap, serializeInstanceQuery } from "./query-helpers-DsMMOtSO.js";
 
-//#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/loaders/loader-utils.ts
-const configuredFetch = async (opts, url, init = {}) => {
-	const fetchImpl = opts.fetch || globalThis.fetch;
-	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
-	}).then(async (r) => {
-		const content = await r.json();
-		if (r.status !== 200) throw new Error(`[${r.status}] ${JSON.stringify(content)}`);
-		return content;
-	});
-};
-
-//#endregion
-//#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/model-pool.ts
 const ROOT_ID = "";
 const dateStrToDay = (dateAsStr) => {
@@ -3010,110 +28,29 @@ var ModelPool = class {
 	constructor(modelMap$1) {
 		this.modelMap = modelMap$1;
 	}
-	addModelInstance(model, id$1, _data) {
+	addModelInstance(model, id, _data) {
 		const instanceById = ensureMapValue(this.data, model, () => new Map());
-		const exists = instanceById.get(id$1);
+		const exists = instanceById.get(id);
 		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);
+		else instanceById.set(id, 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);
+			else Object.entries(payload).forEach(([id, payload$1]) => {
+				this.addModelInstance(modelName, id, payload$1);
 			});
 		});
 	}
-	get(model, id$1) {
+	get(model, id) {
 		const instances = this.data.get(model);
-		return instances?.get(id$1) ?? null;
+		return instances?.get(id) ?? null;
 	}
 };
 
-//#endregion
-//#region src/query-helpers.ts
-const normalizeQuery = (q) => {
-	return JSON.stringify(q);
-};
-const getRelKey = (r, k) => {
-	const getSuffix = () => {
-		if (r.type === "exists") return `exists:`;
-		if (r.type === "count") return `count:`;
-		return "";
-	};
-	const suffix = getSuffix();
-	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 `${suffix}${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 `${suffix}${k}(${normalizeQuery(q)})`;
-};
-const processRelations = (rels) => {
-	const result = {};
-	for (const [key, relq] of Object.entries(rels)) {
-		const asArray = Array.isArray(relq) ? relq : [relq];
-		for (const rel of asArray) {
-			if (!rel) continue;
-			result[getRelKey(rel, key)] = makeRelQuerySerializable(rel);
-		}
-	}
-	return result;
-};
-const makeModelQuerySerializable = (q) => {
-	if (!q.relations) return q;
-	return {
-		...q,
-		relations: processRelations(q.relations)
-	};
-};
-const makeRelQuerySerializable = (r) => {
-	if (r.type === "exists" || r.type === "count") return { asField: true };
-	return {
-		asField: false,
-		fields: r.fields,
-		relations: r.relations ? processRelations(r.relations) : void 0
-	};
-};
-const serializeModel = (q) => {
-	const list = q.fields ? [...q.fields] : [];
-	if (!q.relations) return list;
-	const relObj = {};
-	Object.entries(q.relations).forEach(([k, r]) => {
-		if (r.asField) list.push(k);
-		else relObj[k] = serializeModel(r);
-	});
-	if (Object.keys(relObj).length) list.push(relObj);
-	return list;
-};
-const serializeInstanceQuery = (q, instances) => {
-	return Object.fromEntries(instances.map((instance) => {
-		const name = instance["~model"];
-		const getKey = () => {
-			if (name === "_root") return "_root";
-			return `${name}(${instance["~key"]})`;
-		};
-		return [getKey(), serializeModel(q)];
-	}));
-};
-
 //#endregion
 //#region src/reconcile-query.ts
 const reconcileInstanceQuery = (query, response, instanceModel, key, store) => {
@@ -3160,7 +97,7 @@ const reconcileInstanceQuery = (query, response, instanceModel, key, store) => {
 							break;
 						default: {
 							result[`~${asName}`] = val;
-							result[asName] = val.map((id$1) => reconcileInstanceQuery(relEntry, response, relModel, `${id$1}`, store));
+							result[asName] = val.map((id) => reconcileInstanceQuery(relEntry, response, relModel, `${id}`, store));
 						}
 					}
 					break;
@@ -3182,14 +119,14 @@ const createSimpleLoader = (opts = {}) => {
 	};
 	return { fetchModel: async (model, ids, q) => {
 		const modelDesc = modelMap[model];
-		const instances = ids.map((id$1) => ({
+		const instances = ids.map((id) => ({
 			"~model": model,
-			"~key": id$1
+			"~key": id
 		}));
 		const response = await fetchWithQuery(serializeInstanceQuery(makeModelQuerySerializable(q), instances));
 		const pool = new ModelPool(modelMap);
 		pool.add(response);
-		return Object.fromEntries(ids.map((id$1) => [id$1, reconcileInstanceQuery(q, response, modelDesc, id$1, pool)]));
+		return Object.fromEntries(ids.map((id) => [id, reconcileInstanceQuery(q, response, modelDesc, id, pool)]));
 	} };
 };