@codecks/fetch 1.0.1 → 2.0.1

package/dist/query-helpers-DndWBcMF.js

@@ -0,0 +1,1203 @@
+//#region src/models/_desc.ts
+const makeModel = (opts) => {
+	return opts;
+};
+const relation = (relName, options) => {
+	return {
+		relName,
+		options
+	};
+};
+
+//#endregion
+//#region src/models/_root.ts
+/** The starting point of every query. */
+const _rootDesc = makeModel({
+	name: "_root",
+	fields: {},
+	relations: {
+		account: relation("account", { type: "hasOne" }),
+		loggedInUser: relation("user", { type: "hasOne" }),
+		releases: relation("release", { type: "hasMany" })
+	},
+	keys: []
+});
+
+//#endregion
+//#region src/models/_fields.ts
+const id = () => {
+	return { type: "id" };
+};
+const withOpts = (type, opts) => ({
+	type,
+	...opts
+});
+const string = (opts) => {
+	return withOpts("string", opts);
+};
+const int = (opts) => {
+	return withOpts("int", opts);
+};
+const bool = (opts) => {
+	return withOpts("bool", opts);
+};
+const date = (opts) => {
+	return withOpts("date", opts);
+};
+const day = (opts) => {
+	return withOpts("day", opts);
+};
+/** A field whose type the reference's schema gives: an enum, a json value, a list of ids, ... */
+const typed = (opts) => ({ type: () => withOpts("typed", opts) });
+const belongsTo = (opts) => {
+	return { type: () => {
+		return withOpts("belongsTo", opts);
+	} };
+};
+
+//#endregion
+//#region src/models/Account.ts
+/** An organization and its settings. */
+const accountDesc = makeModel({
+	name: "account",
+	fields: {
+		allowInheritHeroCover: bool({ stability: "preview" }),
+		attachmentCoverMode: typed({ stability: "preview" }).type(),
+		createdAt: date({}),
+		dependenciesEnabled: bool({}),
+		dueDateEnabled: bool({}),
+		effortScale: typed({}).type(),
+		fallbackEffort: int({ stability: "preview" }),
+		hideCompletedCardCountForDecks: bool({ stability: "preview" }),
+		id: id(),
+		maxHandSlotCount: int({ stability: "preview" }),
+		milestonesEnabled: bool({}),
+		name: string({}),
+		priorityLabels: typed({}).type(),
+		sprintsEnabled: bool({}),
+		startWeekday: typed({}).type(),
+		statusChangeDurations: typed({ stability: "preview" }).type(),
+		subdomain: string({}),
+		timeTrackingMode: typed({ stability: "preview" }).type(),
+		timelineScaleType: typed({ stability: "preview" }).type(),
+		visionBoardEnabled: bool({ stability: "preview" }),
+		workdays: typed({}).type(),
+		workflowMode: typed({ stability: "preview" }).type()
+	},
+	relations: {
+		archivedProjects: relation("project", { type: "hasMany" }),
+		attachments: relation("attachment", { type: "hasMany" }),
+		cards: relation("card", { type: "hasMany" }),
+		decks: relation("deck", { type: "hasMany" }),
+		files: relation("file", { type: "hasMany" }),
+		handCards: relation("handCard", { type: "hasMany" }),
+		milestones: relation("milestone", { type: "hasMany" }),
+		projects: relation("project", { type: "hasMany" }),
+		queueEntries: relation("queueEntry", { type: "hasMany" }),
+		resolvables: relation("resolvable", { type: "hasMany" }),
+		sprintConfigs: relation("sprintConfig", { type: "hasMany" }),
+		sprints: relation("sprint", { type: "hasMany" }),
+		workflowItems: relation("workflowItem", {
+			type: "hasMany",
+			stability: "preview"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Attachment.ts
+/** A file attached to a card. */
+const attachmentDesc = makeModel({
+	name: "attachment",
+	fields: {
+		accountId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		content: string({}),
+		createdAt: date({}),
+		creatorId: belongsTo({ optional: true }).type(),
+		fileId: belongsTo({}).type(),
+		id: id(),
+		title: string({})
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId",
+			optional: true
+		}),
+		file: relation("file", {
+			type: "belongsTo",
+			fk: "fileId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Card.ts
+/**
+* A task or a document card when `isDoc` is set or a hero card if it contains sub cards.
+The card's
+* color is derived from `status`, `visibility`, `isDoc` and whether it has sub cards or open block
+* or review conversations.
+*/
+const cardDesc = makeModel({
+	name: "card",
+	fields: {
+		accountId: belongsTo({}).type(),
+		accountSeq: int({}),
+		assigneeId: belongsTo({ optional: true }).type(),
+		cardId: id(),
+		checkboxInfo: typed({ stability: "preview" }).type(),
+		checkboxStats: typed({}).type(),
+		content: string({}),
+		coverFileId: belongsTo({ optional: true }).type(),
+		createdAt: date({}),
+		creatorId: belongsTo({ optional: true }).type(),
+		deckId: belongsTo({ optional: true }).type(),
+		derivedStatus: typed({ stability: "preview" }).type(),
+		dueDate: day({ optional: true }),
+		effort: int({ optional: true }),
+		hasBlockingDeps: bool({ stability: "preview" }),
+		isBlockingDep: bool({ stability: "preview" }),
+		isDoc: bool({ optional: true }),
+		lastUpdatedAt: date({}),
+		masterTags: typed({}).type(),
+		mentionedUsers: typed({ stability: "preview" }).type(),
+		milestoneId: belongsTo({ optional: true }).type(),
+		parentCardId: belongsTo({ optional: true }).type(),
+		priority: typed({ optional: true }).type(),
+		sourceWorkflowItemId: belongsTo({
+			optional: true,
+			stability: "preview"
+		}).type(),
+		sprintId: belongsTo({ optional: true }).type(),
+		status: typed({}).type(),
+		tags: typed({}).type(),
+		title: string({}),
+		version: int({}),
+		visibility: typed({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		assignee: relation("user", {
+			type: "belongsTo",
+			fk: "assigneeId",
+			optional: true
+		}),
+		attachments: relation("attachment", {
+			type: "hasMany",
+			fkAsArray: true
+		}),
+		cardReferences: relation("card", {
+			type: "hasMany",
+			fkAsArray: true,
+			stability: "preview"
+		}),
+		childCards: relation("card", {
+			type: "hasMany",
+			fkAsArray: true
+		}),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId",
+			optional: true
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId",
+			optional: true
+		}),
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId",
+			optional: true
+		}),
+		diffs: relation("cardHistory", {
+			type: "hasMany",
+			stability: "preview"
+		}),
+		handCards: relation("handCard", { type: "hasMany" }),
+		inDeps: relation("card", {
+			type: "hasMany",
+			fkAsArray: true,
+			stability: "preview"
+		}),
+		milestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "milestoneId",
+			optional: true
+		}),
+		outDeps: relation("card", {
+			type: "hasMany",
+			fkAsArray: true,
+			stability: "preview"
+		}),
+		parentCard: relation("card", {
+			type: "belongsTo",
+			fk: "parentCardId",
+			optional: true
+		}),
+		queueEntries: relation("queueEntry", { type: "hasMany" }),
+		resolvableEntries: relation("resolvableEntry", { type: "hasMany" }),
+		resolvables: relation("resolvable", { type: "hasMany" }),
+		sourceWorkflowItem: relation("workflowItem", {
+			type: "belongsTo",
+			fk: "sourceWorkflowItemId",
+			optional: true,
+			stability: "preview"
+		}),
+		sprint: relation("sprint", {
+			type: "belongsTo",
+			fk: "sprintId",
+			optional: true
+		})
+	},
+	keys: ["cardId"]
+});
+
+//#endregion
+//#region src/models/CardHistory.ts
+/**
+* One version of a card and what changed in it. The web app shows these in the card's history.
+* @experimental `preview` in the Codecks API: may change in any release.
+*/
+const cardHistoryDesc = makeModel({
+	name: "cardHistory",
+	stability: "preview",
+	fields: {
+		accountId: belongsTo({ stability: "preview" }).type(),
+		cardId: belongsTo({ stability: "preview" }).type(),
+		changerId: belongsTo({
+			optional: true,
+			stability: "preview"
+		}).type(),
+		diff: typed({ stability: "preview" }).type(),
+		version: int({ stability: "preview" }),
+		versionCreatedAt: date({ stability: "preview" })
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId",
+			stability: "preview"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId",
+			stability: "preview"
+		}),
+		changer: relation("user", {
+			type: "belongsTo",
+			fk: "changerId",
+			optional: true,
+			stability: "preview"
+		})
+	},
+	keys: ["cardId", "version"]
+});
+
+//#endregion
+//#region src/models/Deck.ts
+/** A list of cards within a project. `deckType` says which kind of cards it is meant for. */
+const deckDesc = makeModel({
+	name: "deck",
+	fields: {
+		accountId: belongsTo({}).type(),
+		accountSeq: int({}),
+		coverColor: string({
+			optional: true,
+			stability: "preview"
+		}),
+		coverFileId: belongsTo({
+			optional: true,
+			stability: "preview"
+		}).type(),
+		createdAt: date({}),
+		creatorId: belongsTo({}).type(),
+		deckType: typed({}).type(),
+		defaultCard: typed({ stability: "preview" }).type(),
+		defaultProjectTagId: belongsTo({ optional: true }).type(),
+		description: string({}),
+		handSyncEnabled: bool({ stability: "preview" }),
+		hasGuardians: bool({ stability: "preview" }),
+		id: id(),
+		isDeleted: bool({}),
+		manualOrderLabels: typed({ stability: "preview" }).type(),
+		milestoneId: belongsTo({ optional: true }).type(),
+		projectId: belongsTo({}).type(),
+		sortValue: string({ stability: "preview" }),
+		spaceId: int({
+			optional: true,
+			stability: "preview"
+		}),
+		title: string({})
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		cards: relation("card", { type: "hasMany" }),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId",
+			optional: true,
+			stability: "preview"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		defaultProjectTag: relation("projectTag", {
+			type: "belongsTo",
+			fk: "defaultProjectTagId",
+			optional: true
+		}),
+		milestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "milestoneId",
+			optional: true
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		workflowItems: relation("workflowItem", {
+			type: "hasMany",
+			stability: "preview"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/File.ts
+/** An uploaded file, like a card attachment or a cover image. */
+const fileDesc = makeModel({
+	name: "file",
+	fields: {
+		accountId: belongsTo({ optional: true }).type(),
+		createdAt: date({}),
+		id: id(),
+		name: string({}),
+		size: int({}),
+		uploaderId: belongsTo({ optional: true }).type(),
+		url: string({})
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId",
+			optional: true
+		}),
+		uploader: relation("user", {
+			type: "belongsTo",
+			fk: "uploaderId",
+			optional: true
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/HandCard.ts
+/** A card a user bookmarked. Deleting the card removes its bookmarks. */
+const handCardDesc = makeModel({
+	name: "handCard",
+	fields: {
+		accountId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		sortIndex: int({}),
+		userId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		})
+	},
+	keys: [
+		"cardId",
+		"userId",
+		"accountId"
+	]
+});
+
+//#endregion
+//#region src/models/Milestone.ts
+/**
+* A date that cards are planned towards. It belongs to a list of projects, or with `isGlobal` to
+* all projects of the organization.
+*/
+const milestoneDesc = makeModel({
+	name: "milestone",
+	fields: {
+		accountId: belongsTo({}).type(),
+		accountSeq: int({}),
+		color: typed({}).type(),
+		coverFileId: belongsTo({
+			optional: true,
+			stability: "preview"
+		}).type(),
+		createdAt: date({}),
+		creatorId: belongsTo({}).type(),
+		date: day({}),
+		description: string({ optional: true }),
+		handSyncEnabled: bool({ stability: "preview" }),
+		id: id(),
+		isDeleted: bool({}),
+		isGlobal: bool({}),
+		manualOrderLabels: typed({ stability: "preview" }).type(),
+		name: string({}),
+		startDate: day({ optional: true }),
+		userCapacities: typed({ stability: "preview" }).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		cards: relation("card", { type: "hasMany" }),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId",
+			optional: true,
+			stability: "preview"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		milestoneProjects: relation("milestoneProject", { type: "hasMany" }),
+		progress: relation("milestoneProgress", {
+			type: "hasMany",
+			stability: "preview"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/MilestoneProgress.ts
+/**
+* The state of a milestone's cards on a day (UTC). A row is only written on days when the numbers
+* change, so a day without a row has the numbers of the row before it.
+* @experimental `preview` in the Codecks API: may change in any release.
+*/
+const milestoneProgressDesc = makeModel({
+	name: "milestoneProgress",
+	stability: "preview",
+	fields: {
+		date: string({ stability: "preview" }),
+		milestoneId: belongsTo({ stability: "preview" }).type(),
+		progress: typed({ stability: "preview" }).type()
+	},
+	relations: { milestone: relation("milestone", {
+		type: "belongsTo",
+		fk: "milestoneId",
+		stability: "preview"
+	}) },
+	keys: ["milestoneId", "date"]
+});
+
+//#endregion
+//#region src/models/MilestoneProject.ts
+/**
+* Links a milestone to a project whose cards and decks can use it. A milestone with `isGlobal` is
+* linked to every project.
+*/
+const milestoneProjectDesc = makeModel({
+	name: "milestoneProject",
+	fields: {
+		accountId: belongsTo({}).type(),
+		milestoneId: belongsTo({}).type(),
+		projectId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		milestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "milestoneId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		})
+	},
+	keys: ["milestoneId", "projectId"]
+});
+
+//#endregion
+//#region src/models/Project.ts
+/** Groups decks. A card belongs to the project of its deck. */
+const projectDesc = makeModel({
+	name: "project",
+	fields: {
+		accountId: belongsTo({}).type(),
+		coverFileId: belongsTo({ optional: true }).type(),
+		createdAt: date({}),
+		id: id(),
+		name: string({}),
+		spaces: typed({ stability: "preview" }).type(),
+		visibility: typed({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId",
+			optional: true
+		}),
+		decks: relation("deck", { type: "hasMany" }),
+		milestoneProjects: relation("milestoneProject", { type: "hasMany" }),
+		sprintProjects: relation("sprintProject", { type: "hasMany" }),
+		tags: relation("projectTag", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/ProjectTag.ts
+/** A tag in a project's tag list. A card in the project with this tag lists it in `masterTags`. */
+const projectTagDesc = makeModel({
+	name: "projectTag",
+	fields: {
+		color: string({ optional: true }),
+		createdAt: date({}),
+		description: string({ optional: true }),
+		emoji: string({ optional: true }),
+		id: id(),
+		projectId: belongsTo({}).type(),
+		tag: string({})
+	},
+	relations: { project: relation("project", {
+		type: "belongsTo",
+		fk: "projectId"
+	}) },
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/QueueEntry.ts
+/**
+* A card in a user's Hand. When a card is done, its owner gets an entry in their Hand's done pile,
+* even if the card wasn't in their Hand.
+*/
+const queueEntryDesc = makeModel({
+	name: "queueEntry",
+	fields: {
+		accountId: belongsTo({}).type(),
+		cardDoneAt: date({ optional: true }),
+		cardId: belongsTo({}).type(),
+		createdAt: date({}),
+		id: id(),
+		sortIndex: int({ optional: true }),
+		userId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Release.ts
+/** An entry in the Codecks changelog. It's the same for every organization. */
+const releaseDesc = makeModel({
+	name: "release",
+	fields: {
+		content: string({}),
+		createdAt: date({}),
+		id: id(),
+		title: string({}),
+		version: string({})
+	},
+	relations: {},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Resolvable.ts
+/**
+* A comment thread on a card. Its `context` says if it's a plain conversation or if it marks the
+* card as blocked or in review.
+*/
+const resolvableDesc = makeModel({
+	name: "resolvable",
+	fields: {
+		accountId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		closedAt: date({ optional: true }),
+		context: typed({}).type(),
+		createdAt: date({}),
+		creatorId: belongsTo({}).type(),
+		id: id(),
+		isClosed: bool({}),
+		reopenedAt: date({ optional: true })
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		closedBy: relation("user", {
+			type: "belongsTo",
+			optional: true
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		entries: relation("resolvableEntry", { type: "hasMany" }),
+		reopenedBy: relation("user", {
+			type: "belongsTo",
+			optional: true
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/ResolvableEntry.ts
+/** A comment in a comment thread. */
+const resolvableEntryDesc = makeModel({
+	name: "resolvableEntry",
+	fields: {
+		authorId: belongsTo({}).type(),
+		cardId: belongsTo({}).type(),
+		content: string({}),
+		createdAt: date({}),
+		entryId: id(),
+		lastChangedAt: date({}),
+		resolvableId: belongsTo({}).type(),
+		version: int({ stability: "preview" })
+	},
+	relations: {
+		author: relation("user", {
+			type: "belongsTo",
+			fk: "authorId"
+		}),
+		card: relation("card", {
+			type: "belongsTo",
+			fk: "cardId"
+		}),
+		reactions: relation("resolvableEntryReaction", {
+			type: "hasMany",
+			stability: "preview"
+		}),
+		resolvable: relation("resolvable", {
+			type: "belongsTo",
+			fk: "resolvableId"
+		})
+	},
+	keys: ["entryId"]
+});
+
+//#endregion
+//#region src/models/ResolvableEntryReaction.ts
+/**
+* An emoji reaction to a comment. A user can add each emoji only once per comment.
+* @experimental `preview` in the Codecks API: may change in any release.
+*/
+const resolvableEntryReactionDesc = makeModel({
+	name: "resolvableEntryReaction",
+	stability: "preview",
+	fields: {
+		accountId: belongsTo({ stability: "preview" }).type(),
+		createdAt: date({ stability: "preview" }),
+		entryId: belongsTo({ stability: "preview" }).type(),
+		id: id(),
+		resolvableId: belongsTo({ stability: "preview" }).type(),
+		userId: belongsTo({ stability: "preview" }).type(),
+		value: typed({ stability: "preview" }).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId",
+			stability: "preview"
+		}),
+		resolvable: relation("resolvable", {
+			type: "belongsTo",
+			fk: "resolvableId",
+			stability: "preview"
+		}),
+		resolvableEntry: relation("resolvableEntry", {
+			type: "belongsTo",
+			fk: "entryId",
+			stability: "preview"
+		}),
+		user: relation("user", {
+			type: "belongsTo",
+			fk: "userId",
+			stability: "preview"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/Sprint.ts
+/**
+* A run: one time box of a Run Config, from `startDate` to `endDate`. Codecks creates the upcoming
+* runs ahead of time and completes a run when it ends.
+*/
+const sprintDesc = makeModel({
+	name: "sprint",
+	fields: {
+		accountId: belongsTo({}).type(),
+		accountSeq: int({}),
+		autoMilestoneId: belongsTo({
+			optional: true,
+			stability: "preview"
+		}).type(),
+		completedAt: date({ optional: true }),
+		coverFileId: belongsTo({
+			optional: true,
+			stability: "preview"
+		}).type(),
+		createdAt: date({}),
+		description: string({ optional: true }),
+		endDate: day({}),
+		handSyncEnabled: bool({ stability: "preview" }),
+		id: id(),
+		index: int({}),
+		isDeleted: bool({}),
+		lockedAt: date({
+			optional: true,
+			stability: "preview"
+		}),
+		manualOrderLabels: typed({ stability: "preview" }).type(),
+		name: string({ optional: true }),
+		sprintConfigId: belongsTo({}).type(),
+		startDate: day({}),
+		userCapacities: typed({ stability: "preview" }).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		autoMilestone: relation("milestone", {
+			type: "belongsTo",
+			fk: "autoMilestoneId",
+			optional: true,
+			stability: "preview"
+		}),
+		cards: relation("card", { type: "hasMany" }),
+		coverFile: relation("file", {
+			type: "belongsTo",
+			fk: "coverFileId",
+			optional: true,
+			stability: "preview"
+		}),
+		progress: relation("sprintProgress", {
+			type: "hasMany",
+			stability: "preview"
+		}),
+		sprintConfig: relation("sprintConfig", {
+			type: "belongsTo",
+			fk: "sprintConfigId"
+		})
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/SprintConfig.ts
+/**
+* A Run Config. It creates runs of the same length one after the other, like sprints, for its
+* projects.
+*/
+const sprintConfigDesc = makeModel({
+	name: "sprintConfig",
+	fields: {
+		accountId: belongsTo({}).type(),
+		autoAssignNewCard: bool({ stability: "preview" }),
+		autoAssignStartedCard: bool({ stability: "preview" }),
+		autoBeastModeDurationHours: int({
+			optional: true,
+			stability: "preview"
+		}),
+		beastGracePeriodHours: int({ stability: "preview" }),
+		color: typed({}).type(),
+		createdAt: date({}),
+		creatorId: belongsTo({}).type(),
+		id: id(),
+		isGlobal: bool({}),
+		moveOnFinish: typed({ stability: "preview" }).type(),
+		name: string({}),
+		runLabelTemplate: string({
+			optional: true,
+			stability: "preview"
+		})
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId"
+		}),
+		progress: relation("sprintConfigProgress", {
+			type: "hasMany",
+			stability: "preview"
+		}),
+		sprintProjects: relation("sprintProject", { type: "hasMany" }),
+		sprints: relation("sprint", { type: "hasMany" })
+	},
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/SprintConfigProgress.ts
+/**
+* The done cards of all runs of a Run Config on a day (UTC). A row is only written on days when the
+* numbers change, so a day without a row has the numbers of the row before it.
+* @experimental `preview` in the Codecks API: may change in any release.
+*/
+const sprintConfigProgressDesc = makeModel({
+	name: "sprintConfigProgress",
+	stability: "preview",
+	fields: {
+		date: string({ stability: "preview" }),
+		progress: typed({ stability: "preview" }).type(),
+		sprintConfigId: belongsTo({ stability: "preview" }).type()
+	},
+	relations: { sprintConfig: relation("sprintConfig", {
+		type: "belongsTo",
+		fk: "sprintConfigId",
+		stability: "preview"
+	}) },
+	keys: ["sprintConfigId", "date"]
+});
+
+//#endregion
+//#region src/models/SprintProgress.ts
+/**
+* The state of a run's cards on a day (UTC). A row is only written on days when the numbers change,
+* so a day without a row has the numbers of the row before it.
+* @experimental `preview` in the Codecks API: may change in any release.
+*/
+const sprintProgressDesc = makeModel({
+	name: "sprintProgress",
+	stability: "preview",
+	fields: {
+		date: string({ stability: "preview" }),
+		progress: typed({ stability: "preview" }).type(),
+		sprintId: belongsTo({ stability: "preview" }).type()
+	},
+	relations: { sprint: relation("sprint", {
+		type: "belongsTo",
+		fk: "sprintId",
+		stability: "preview"
+	}) },
+	keys: ["sprintId", "date"]
+});
+
+//#endregion
+//#region src/models/SprintProject.ts
+/**
+* Links a run config to a project whose cards can be planned into its runs. A run config with
+* `isGlobal` is linked to every project.
+*/
+const sprintProjectDesc = makeModel({
+	name: "sprintProject",
+	fields: {
+		accountId: belongsTo({}).type(),
+		projectId: belongsTo({}).type(),
+		sprintConfigId: belongsTo({}).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId"
+		}),
+		project: relation("project", {
+			type: "belongsTo",
+			fk: "projectId"
+		}),
+		sprintConfig: relation("sprintConfig", {
+			type: "belongsTo",
+			fk: "sprintConfigId"
+		})
+	},
+	keys: ["sprintConfigId", "projectId"]
+});
+
+//#endregion
+//#region src/models/User.ts
+/**
+* A person, or an integration or API token that acts in an organization. `kind` tells them apart.
+*/
+const userDesc = makeModel({
+	name: "user",
+	fields: {
+		fullName: string({ optional: true }),
+		id: id(),
+		isIntegration: bool({}),
+		kind: typed({}).type(),
+		name: string({}),
+		profileImageId: belongsTo({ optional: true }).type(),
+		timezone: string({
+			optional: true,
+			stability: "preview"
+		})
+	},
+	relations: { profileImage: relation("file", {
+		type: "belongsTo",
+		fk: "profileImageId",
+		optional: true
+	}) },
+	keys: ["id"]
+});
+
+//#endregion
+//#region src/models/WorkflowItem.ts
+/**
+* A Journey Step: a template for a sub card. Starting a deck's journey on a card creates a sub card
+* from each of its steps.
+* @experimental `preview` in the Codecks API: may change in any release.
+*/
+const workflowItemDesc = makeModel({
+	name: "workflowItem",
+	stability: "preview",
+	fields: {
+		accountId: belongsTo({ stability: "preview" }).type(),
+		accountSeq: int({ stability: "preview" }),
+		assigneeId: belongsTo({
+			optional: true,
+			stability: "preview"
+		}).type(),
+		checkboxInfo: typed({ stability: "preview" }).type(),
+		checkboxStats: typed({ stability: "preview" }).type(),
+		content: string({ stability: "preview" }),
+		createdAt: date({ stability: "preview" }),
+		creatorId: belongsTo({ stability: "preview" }).type(),
+		deckId: belongsTo({ stability: "preview" }).type(),
+		effort: int({
+			optional: true,
+			stability: "preview"
+		}),
+		itemId: id(),
+		label: string({
+			optional: true,
+			stability: "preview"
+		}),
+		lastUpdatedAt: date({ stability: "preview" }),
+		masterTags: typed({ stability: "preview" }).type(),
+		mentionedUsers: typed({ stability: "preview" }).type(),
+		priority: typed({
+			optional: true,
+			stability: "preview"
+		}).type(),
+		sortValue: string({ stability: "preview" }),
+		tags: typed({ stability: "preview" }).type(),
+		targetDeckId: belongsTo({
+			optional: true,
+			stability: "preview"
+		}).type(),
+		title: string({ stability: "preview" }),
+		version: int({ stability: "preview" }),
+		visibility: typed({ stability: "preview" }).type()
+	},
+	relations: {
+		account: relation("account", {
+			type: "belongsTo",
+			fk: "accountId",
+			stability: "preview"
+		}),
+		assignee: relation("user", {
+			type: "belongsTo",
+			fk: "assigneeId",
+			optional: true,
+			stability: "preview"
+		}),
+		creator: relation("user", {
+			type: "belongsTo",
+			fk: "creatorId",
+			stability: "preview"
+		}),
+		deck: relation("deck", {
+			type: "belongsTo",
+			fk: "deckId",
+			stability: "preview"
+		}),
+		inDeps: relation("workflowItem", {
+			type: "hasMany",
+			fkAsArray: true,
+			stability: "preview"
+		}),
+		outDeps: relation("workflowItem", {
+			type: "hasMany",
+			fkAsArray: true,
+			stability: "preview"
+		}),
+		targetDeck: relation("deck", {
+			type: "belongsTo",
+			fk: "targetDeckId",
+			optional: true,
+			stability: "preview"
+		})
+	},
+	keys: ["itemId"]
+});
+
+//#endregion
+//#region src/models/index.ts
+const modelMap = {
+	_root: _rootDesc,
+	account: accountDesc,
+	attachment: attachmentDesc,
+	card: cardDesc,
+	cardHistory: cardHistoryDesc,
+	deck: deckDesc,
+	file: fileDesc,
+	handCard: handCardDesc,
+	milestone: milestoneDesc,
+	milestoneProgress: milestoneProgressDesc,
+	milestoneProject: milestoneProjectDesc,
+	project: projectDesc,
+	projectTag: projectTagDesc,
+	queueEntry: queueEntryDesc,
+	release: releaseDesc,
+	resolvable: resolvableDesc,
+	resolvableEntry: resolvableEntryDesc,
+	resolvableEntryReaction: resolvableEntryReactionDesc,
+	sprint: sprintDesc,
+	sprintConfig: sprintConfigDesc,
+	sprintConfigProgress: sprintConfigProgressDesc,
+	sprintProgress: sprintProgressDesc,
+	sprintProject: sprintProjectDesc,
+	user: userDesc,
+	workflowItem: workflowItemDesc
+};
+
+//#endregion
+//#region src/query-helpers.ts
+const normalizeQuery = (q) => {
+	return JSON.stringify(q);
+};
+const queryToKey = normalizeQuery;
+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
+export { _rootDesc as _rootDesc$1, getRelKey, makeModelQuerySerializable, makeRelQuerySerializable, modelMap, queryToKey, serializeInstanceQuery, serializeModel };