@codecks/fetch 1.0.1 → 2.0.0

package/dist/store-ztk8y6Pm.d.ts

@@ -0,0 +1,1203 @@
+import { ModelDesc, ModelQuery, RelationEntry, TypedField } from "./query-type-DPNcQFpZ.js";
+import { AccountId, AttachmentId, CardId, CardVisibility, Checkbox, CheckboxStats, DeckId, DefaultCard, DerivedStatus, FileId, MilestoneColor, MilestoneId, Priority, ProjectId, ProjectTagId, QueueEntryId, ReleaseId, ResolvableEntryId, ResolvableEntryReactionId, ResolvableId, SprintConfigId, SprintId, StartWeekday, TimeTrackingMode, TimelineScaleType, UserId, Workdays, WorkflowItemId, WorkflowMode, modelMap$1 as modelMap } from "./loader-utils-BZWanWDZ.js";
+import { BaseLoader, LoaderResult, MissingDataRequest } from "./loader-types-D2Pf8qzH.js";
+
+//#region src/_exploration/optimistic-manager.d.ts
+
+/**
+ * Represents a single optimistic update layer
+ * Contains field updates for one mutation
+ * Internal implementation - wrapped by ImmediateCache to provide full OptimisticUpdater interface
+ */
+declare class OptimisticLayer {
+  private data;
+  private affectedFields;
+  setField(model: string, id: string, field: string, value: any): void;
+  hasChanges(): boolean;
+  getAffectedFieldKeys(): Iterable<string>;
+  entries(): IterableIterator<[string, any]>;
+}
+/**
+ * Manages a stack of optimistic layers with O(1) lookups
+ *
+ * Design:
+ * - Maintains a stack of layers (one per in-flight mutation)
+ * - Rebuilds flattened view when layers added/removed for fast reads
+ * - Later layers override earlier ones (parallel updates supported)
+ * - Auto-cleanup via promise lifecycle
+ */
+//#endregion
+//#region src/_exploration/immediate-cache.d.ts
+type FieldMeta = {
+  state: "optimistic";
+} | {
+  state: "fresh";
+} | {
+  state: "dirty";
+};
+interface FieldCache<T = any> {
+  value: T;
+  partKeys: string[];
+  meta: FieldMeta;
+}
+type FieldLocation = {
+  model: string;
+  id: string;
+  field: string;
+  fieldKey: string;
+  type: "field" | "relation";
+  cache: FieldCache;
+};
+type ModelInstance = Map<string, FieldCache>;
+type ModelCache = Map<string, ModelInstance>;
+type FieldSub = () => void;
+/**
+ * Wrapper that provides full OptimisticUpdater interface
+ * Delegates writes to OptimisticLayer and reads to ImmediateCache
+ */
+declare class OptimisticUpdater {
+  private layer;
+  private cache;
+  constructor(layer: OptimisticLayer,
+  // OptimisticLayer from optimistic-manager
+  cache: ImmediateCache);
+  setField(model: string, id: string, field: string, value: any): void;
+  getField(model: string, id: string, field: string): FieldCache | undefined;
+}
+declare class ImmediateCache {
+  cache: ModelCache;
+  partKeyToFields: Map<string, FieldLocation[]>;
+  private fieldSubscriptions;
+  private optimisticManager;
+  private getInstanceKey;
+  get(model: string, key: string, field: string): FieldCache | undefined;
+  subscribe(fieldKey: string, notifyFn: FieldSub): () => void;
+  set(model: string, key: string, partialInstance: Record<string, {
+    value: unknown;
+    partKeys: string[];
+    type: "field" | "relation";
+  }>, meta: FieldMeta): FieldSub[];
+  markDirty(partKeys: string[]): MissingDataRequest[];
+  /**
+   * Create a new optimistic layer bound to a promise and apply updates
+   * The layer will be automatically removed when the promise settles
+   * @param promise - Promise to bind the layer lifecycle to
+   * @param updateFn - Function to apply optimistic updates to the layer
+   * @returns The updater object with both read and write capabilities
+   */
+  createOptimisticLayer(promise: Promise<any>, updateFn: (updater: OptimisticUpdater) => void): OptimisticUpdater;
+}
+//#endregion
+//#region src/_exploration/store.d.ts
+type QueryDep = {
+  keys: string[];
+};
+type ModelMap = typeof modelMap;
+declare class Store {
+  private loader;
+  cache: ImmediateCache;
+  modelMap: {
+    _root: ModelDesc<"_root", {}, {
+      account: RelationEntry<"account", {
+        readonly type: "hasOne";
+      }>;
+      loggedInUser: RelationEntry<"user", {
+        readonly type: "hasOne";
+      }>;
+      releases: RelationEntry<"release", {
+        readonly type: "hasMany";
+      }>;
+    }, []>;
+    account: ModelDesc<"account", {
+      allowInheritHeroCover: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      attachmentCoverMode: TypedField<"typed", (string & {}) | "none" | "first" | "last", {
+        readonly stability: "preview";
+      }>;
+      createdAt: TypedField<"date", Date, {}>;
+      dependenciesEnabled: TypedField<"bool", boolean, {}>;
+      dueDateEnabled: TypedField<"bool", boolean, {}>;
+      effortScale: TypedField<"typed", number[], {}>;
+      fallbackEffort: TypedField<"int", number, {
+        readonly stability: "preview";
+      }>;
+      hideCompletedCardCountForDecks: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      id: TypedField<"id", AccountId, {}>;
+      maxHandSlotCount: TypedField<"int", number, {
+        readonly stability: "preview";
+      }>;
+      milestonesEnabled: TypedField<"bool", boolean, {}>;
+      name: TypedField<"string", string, {}>;
+      priorityLabels: TypedField<"typed", {
+        a: string;
+        b: string;
+        c: string;
+      }, {}>;
+      sprintsEnabled: TypedField<"bool", boolean, {}>;
+      startWeekday: TypedField<"typed", StartWeekday, {}>;
+      statusChangeDurations: TypedField<"typed", {
+        snooze: number;
+        archive: number | null;
+      }, {
+        readonly stability: "preview";
+      }>;
+      subdomain: TypedField<"string", string, {}>;
+      timeTrackingMode: TypedField<"typed", TimeTrackingMode, {
+        readonly stability: "preview";
+      }>;
+      timelineScaleType: TypedField<"typed", TimelineScaleType, {
+        readonly stability: "preview";
+      }>;
+      visionBoardEnabled: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      workdays: TypedField<"typed", Workdays, {}>;
+      workflowMode: TypedField<"typed", WorkflowMode, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      archivedProjects: RelationEntry<"project", {
+        readonly type: "hasMany";
+      }>;
+      attachments: RelationEntry<"attachment", {
+        readonly type: "hasMany";
+      }>;
+      cards: RelationEntry<"card", {
+        readonly type: "hasMany";
+      }>;
+      decks: RelationEntry<"deck", {
+        readonly type: "hasMany";
+      }>;
+      files: RelationEntry<"file", {
+        readonly type: "hasMany";
+      }>;
+      handCards: RelationEntry<"handCard", {
+        readonly type: "hasMany";
+      }>;
+      milestones: RelationEntry<"milestone", {
+        readonly type: "hasMany";
+      }>;
+      projects: RelationEntry<"project", {
+        readonly type: "hasMany";
+      }>;
+      queueEntries: RelationEntry<"queueEntry", {
+        readonly type: "hasMany";
+      }>;
+      resolvables: RelationEntry<"resolvable", {
+        readonly type: "hasMany";
+      }>;
+      sprintConfigs: RelationEntry<"sprintConfig", {
+        readonly type: "hasMany";
+      }>;
+      sprints: RelationEntry<"sprint", {
+        readonly type: "hasMany";
+      }>;
+      workflowItems: RelationEntry<"workflowItem", {
+        readonly type: "hasMany";
+        readonly stability: "preview";
+      }>;
+    }, ["id"]>;
+    attachment: ModelDesc<"attachment", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      cardId: TypedField<"belongsTo", CardId, {}>;
+      content: TypedField<"string", string, {}>;
+      createdAt: TypedField<"date", Date, {}>;
+      creatorId: TypedField<"belongsTo", UserId, {
+        readonly optional: true;
+      }>;
+      fileId: TypedField<"belongsTo", FileId, {}>;
+      id: TypedField<"id", AttachmentId, {}>;
+      title: TypedField<"string", string, {}>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      card: RelationEntry<"card", {
+        readonly type: "belongsTo";
+        readonly fk: "cardId";
+      }>;
+      creator: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "creatorId";
+        readonly optional: true;
+      }>;
+      file: RelationEntry<"file", {
+        readonly type: "belongsTo";
+        readonly fk: "fileId";
+      }>;
+    }, ["id"]>;
+    card: ModelDesc<"card", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      accountSeq: TypedField<"int", number, {}>;
+      assigneeId: TypedField<"belongsTo", UserId, {
+        readonly optional: true;
+      }>;
+      cardId: TypedField<"id", CardId, {}>;
+      checkboxInfo: TypedField<"typed", Checkbox[], {
+        readonly stability: "preview";
+      }>;
+      checkboxStats: TypedField<"typed", CheckboxStats, {}>;
+      content: TypedField<"string", string, {}>;
+      coverFileId: TypedField<"belongsTo", FileId, {
+        readonly optional: true;
+      }>;
+      createdAt: TypedField<"date", Date, {}>;
+      creatorId: TypedField<"belongsTo", UserId, {
+        readonly optional: true;
+      }>;
+      deckId: TypedField<"belongsTo", DeckId, {
+        readonly optional: true;
+      }>;
+      derivedStatus: TypedField<"typed", DerivedStatus, {
+        readonly stability: "preview";
+      }>;
+      dueDate: TypedField<"day", {
+        day: number;
+        month: number;
+        year: number;
+      }, {
+        readonly optional: true;
+      }>;
+      effort: TypedField<"int", number, {
+        readonly optional: true;
+      }>;
+      hasBlockingDeps: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      isBlockingDep: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      isDoc: TypedField<"bool", boolean, {
+        readonly optional: true;
+      }>;
+      lastUpdatedAt: TypedField<"date", Date, {}>;
+      masterTags: TypedField<"typed", string[], {}>;
+      mentionedUsers: TypedField<"typed", UserId[], {
+        readonly stability: "preview";
+      }>;
+      milestoneId: TypedField<"belongsTo", MilestoneId, {
+        readonly optional: true;
+      }>;
+      parentCardId: TypedField<"belongsTo", CardId, {
+        readonly optional: true;
+      }>;
+      priority: TypedField<"typed", Priority, {
+        readonly optional: true;
+      }>;
+      sourceWorkflowItemId: TypedField<"belongsTo", WorkflowItemId, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      sprintId: TypedField<"belongsTo", SprintId, {
+        readonly optional: true;
+      }>;
+      status: TypedField<"typed", (string & {}) | "started" | "done" | "snoozing" | "not_started", {}>;
+      tags: TypedField<"typed", string[], {}>;
+      title: TypedField<"string", string, {}>;
+      version: TypedField<"int", number, {}>;
+      visibility: TypedField<"typed", CardVisibility, {}>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      assignee: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "assigneeId";
+        readonly optional: true;
+      }>;
+      attachments: RelationEntry<"attachment", {
+        readonly type: "hasMany";
+        readonly fkAsArray: true;
+      }>;
+      cardReferences: RelationEntry<"card", {
+        readonly type: "hasMany";
+        readonly fkAsArray: true;
+        readonly stability: "preview";
+      }>;
+      childCards: RelationEntry<"card", {
+        readonly type: "hasMany";
+        readonly fkAsArray: true;
+      }>;
+      coverFile: RelationEntry<"file", {
+        readonly type: "belongsTo";
+        readonly fk: "coverFileId";
+        readonly optional: true;
+      }>;
+      creator: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "creatorId";
+        readonly optional: true;
+      }>;
+      deck: RelationEntry<"deck", {
+        readonly type: "belongsTo";
+        readonly fk: "deckId";
+        readonly optional: true;
+      }>;
+      diffs: RelationEntry<"cardHistory", {
+        readonly type: "hasMany";
+        readonly stability: "preview";
+      }>;
+      handCards: RelationEntry<"handCard", {
+        readonly type: "hasMany";
+      }>;
+      inDeps: RelationEntry<"card", {
+        readonly type: "hasMany";
+        readonly fkAsArray: true;
+        readonly stability: "preview";
+      }>;
+      milestone: RelationEntry<"milestone", {
+        readonly type: "belongsTo";
+        readonly fk: "milestoneId";
+        readonly optional: true;
+      }>;
+      outDeps: RelationEntry<"card", {
+        readonly type: "hasMany";
+        readonly fkAsArray: true;
+        readonly stability: "preview";
+      }>;
+      parentCard: RelationEntry<"card", {
+        readonly type: "belongsTo";
+        readonly fk: "parentCardId";
+        readonly optional: true;
+      }>;
+      queueEntries: RelationEntry<"queueEntry", {
+        readonly type: "hasMany";
+      }>;
+      resolvableEntries: RelationEntry<"resolvableEntry", {
+        readonly type: "hasMany";
+      }>;
+      resolvables: RelationEntry<"resolvable", {
+        readonly type: "hasMany";
+      }>;
+      sourceWorkflowItem: RelationEntry<"workflowItem", {
+        readonly type: "belongsTo";
+        readonly fk: "sourceWorkflowItemId";
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      sprint: RelationEntry<"sprint", {
+        readonly type: "belongsTo";
+        readonly fk: "sprintId";
+        readonly optional: true;
+      }>;
+    }, ["cardId"]>;
+    cardHistory: ModelDesc<"cardHistory", {
+      accountId: TypedField<"belongsTo", AccountId, {
+        readonly stability: "preview";
+      }>;
+      cardId: TypedField<"belongsTo", CardId, {
+        readonly stability: "preview";
+      }>;
+      changerId: TypedField<"belongsTo", UserId, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      diff: TypedField<"typed", {
+        [key: string]: unknown;
+      }, {
+        readonly stability: "preview";
+      }>;
+      version: TypedField<"int", number, {
+        readonly stability: "preview";
+      }>;
+      versionCreatedAt: TypedField<"date", Date, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+        readonly stability: "preview";
+      }>;
+      card: RelationEntry<"card", {
+        readonly type: "belongsTo";
+        readonly fk: "cardId";
+        readonly stability: "preview";
+      }>;
+      changer: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "changerId";
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+    }, ["cardId", "version"]>;
+    deck: ModelDesc<"deck", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      accountSeq: TypedField<"int", number, {}>;
+      coverColor: TypedField<"string", string, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      coverFileId: TypedField<"belongsTo", FileId, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      createdAt: TypedField<"date", Date, {}>;
+      creatorId: TypedField<"belongsTo", UserId, {}>;
+      deckType: TypedField<"typed", (string & {}) | "doc" | "hero" | "task" | "mixed", {}>;
+      defaultCard: TypedField<"typed", DefaultCard, {
+        readonly stability: "preview";
+      }>;
+      defaultProjectTagId: TypedField<"belongsTo", ProjectTagId, {
+        readonly optional: true;
+      }>;
+      description: TypedField<"string", string, {}>;
+      handSyncEnabled: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      hasGuardians: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      id: TypedField<"id", DeckId, {}>;
+      isDeleted: TypedField<"bool", boolean, {}>;
+      manualOrderLabels: TypedField<"typed", (string | null)[], {
+        readonly stability: "preview";
+      }>;
+      milestoneId: TypedField<"belongsTo", MilestoneId, {
+        readonly optional: true;
+      }>;
+      projectId: TypedField<"belongsTo", ProjectId, {}>;
+      sortValue: TypedField<"string", string, {
+        readonly stability: "preview";
+      }>;
+      spaceId: TypedField<"int", number, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      title: TypedField<"string", string, {}>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      cards: RelationEntry<"card", {
+        readonly type: "hasMany";
+      }>;
+      coverFile: RelationEntry<"file", {
+        readonly type: "belongsTo";
+        readonly fk: "coverFileId";
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      creator: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "creatorId";
+      }>;
+      defaultProjectTag: RelationEntry<"projectTag", {
+        readonly type: "belongsTo";
+        readonly fk: "defaultProjectTagId";
+        readonly optional: true;
+      }>;
+      milestone: RelationEntry<"milestone", {
+        readonly type: "belongsTo";
+        readonly fk: "milestoneId";
+        readonly optional: true;
+      }>;
+      project: RelationEntry<"project", {
+        readonly type: "belongsTo";
+        readonly fk: "projectId";
+      }>;
+      workflowItems: RelationEntry<"workflowItem", {
+        readonly type: "hasMany";
+        readonly stability: "preview";
+      }>;
+    }, ["id"]>;
+    file: ModelDesc<"file", {
+      accountId: TypedField<"belongsTo", AccountId, {
+        readonly optional: true;
+      }>;
+      createdAt: TypedField<"date", Date, {}>;
+      id: TypedField<"id", FileId, {}>;
+      name: TypedField<"string", string, {}>;
+      size: TypedField<"int", number, {}>;
+      uploaderId: TypedField<"belongsTo", UserId, {
+        readonly optional: true;
+      }>;
+      url: TypedField<"string", string, {}>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+        readonly optional: true;
+      }>;
+      uploader: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "uploaderId";
+        readonly optional: true;
+      }>;
+    }, ["id"]>;
+    handCard: ModelDesc<"handCard", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      cardId: TypedField<"belongsTo", CardId, {}>;
+      sortIndex: TypedField<"int", number, {}>;
+      userId: TypedField<"belongsTo", UserId, {}>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      card: RelationEntry<"card", {
+        readonly type: "belongsTo";
+        readonly fk: "cardId";
+      }>;
+      user: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "userId";
+      }>;
+    }, ["cardId", "userId", "accountId"]>;
+    milestone: ModelDesc<"milestone", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      accountSeq: TypedField<"int", number, {}>;
+      color: TypedField<"typed", MilestoneColor, {}>;
+      coverFileId: TypedField<"belongsTo", FileId, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      createdAt: TypedField<"date", Date, {}>;
+      creatorId: TypedField<"belongsTo", UserId, {}>;
+      date: TypedField<"day", {
+        day: number;
+        month: number;
+        year: number;
+      }, {}>;
+      description: TypedField<"string", string, {
+        readonly optional: true;
+      }>;
+      handSyncEnabled: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      id: TypedField<"id", MilestoneId, {}>;
+      isDeleted: TypedField<"bool", boolean, {}>;
+      isGlobal: TypedField<"bool", boolean, {}>;
+      manualOrderLabels: TypedField<"typed", (string | null)[], {
+        readonly stability: "preview";
+      }>;
+      name: TypedField<"string", string, {}>;
+      startDate: TypedField<"day", {
+        day: number;
+        month: number;
+        year: number;
+      }, {
+        readonly optional: true;
+      }>;
+      userCapacities: TypedField<"typed", {
+        [userId: UserId]: number;
+      }, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      cards: RelationEntry<"card", {
+        readonly type: "hasMany";
+      }>;
+      coverFile: RelationEntry<"file", {
+        readonly type: "belongsTo";
+        readonly fk: "coverFileId";
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      creator: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "creatorId";
+      }>;
+      milestoneProjects: RelationEntry<"milestoneProject", {
+        readonly type: "hasMany";
+      }>;
+      progress: RelationEntry<"milestoneProgress", {
+        readonly type: "hasMany";
+        readonly stability: "preview";
+      }>;
+    }, ["id"]>;
+    milestoneProgress: ModelDesc<"milestoneProgress", {
+      date: TypedField<"string", string, {
+        readonly stability: "preview";
+      }>;
+      milestoneId: TypedField<"belongsTo", MilestoneId, {
+        readonly stability: "preview";
+      }>;
+      progress: TypedField<"typed", unknown, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      milestone: RelationEntry<"milestone", {
+        readonly type: "belongsTo";
+        readonly fk: "milestoneId";
+        readonly stability: "preview";
+      }>;
+    }, ["milestoneId", "date"]>;
+    milestoneProject: ModelDesc<"milestoneProject", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      milestoneId: TypedField<"belongsTo", MilestoneId, {}>;
+      projectId: TypedField<"belongsTo", ProjectId, {}>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      milestone: RelationEntry<"milestone", {
+        readonly type: "belongsTo";
+        readonly fk: "milestoneId";
+      }>;
+      project: RelationEntry<"project", {
+        readonly type: "belongsTo";
+        readonly fk: "projectId";
+      }>;
+    }, ["milestoneId", "projectId"]>;
+    project: ModelDesc<"project", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      coverFileId: TypedField<"belongsTo", FileId, {
+        readonly optional: true;
+      }>;
+      createdAt: TypedField<"date", Date, {}>;
+      id: TypedField<"id", ProjectId, {}>;
+      name: TypedField<"string", string, {}>;
+      spaces: TypedField<"typed", unknown, {
+        readonly stability: "preview";
+      }>;
+      visibility: TypedField<"typed", (string & {}) | "deleted" | "archived" | "default", {}>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      coverFile: RelationEntry<"file", {
+        readonly type: "belongsTo";
+        readonly fk: "coverFileId";
+        readonly optional: true;
+      }>;
+      decks: RelationEntry<"deck", {
+        readonly type: "hasMany";
+      }>;
+      milestoneProjects: RelationEntry<"milestoneProject", {
+        readonly type: "hasMany";
+      }>;
+      sprintProjects: RelationEntry<"sprintProject", {
+        readonly type: "hasMany";
+      }>;
+      tags: RelationEntry<"projectTag", {
+        readonly type: "hasMany";
+      }>;
+    }, ["id"]>;
+    projectTag: ModelDesc<"projectTag", {
+      color: TypedField<"string", string, {
+        readonly optional: true;
+      }>;
+      createdAt: TypedField<"date", Date, {}>;
+      description: TypedField<"string", string, {
+        readonly optional: true;
+      }>;
+      emoji: TypedField<"string", string, {
+        readonly optional: true;
+      }>;
+      id: TypedField<"id", ProjectTagId, {}>;
+      projectId: TypedField<"belongsTo", ProjectId, {}>;
+      tag: TypedField<"string", string, {}>;
+    }, {
+      project: RelationEntry<"project", {
+        readonly type: "belongsTo";
+        readonly fk: "projectId";
+      }>;
+    }, ["id"]>;
+    queueEntry: ModelDesc<"queueEntry", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      cardDoneAt: TypedField<"date", Date, {
+        readonly optional: true;
+      }>;
+      cardId: TypedField<"belongsTo", CardId, {}>;
+      createdAt: TypedField<"date", Date, {}>;
+      id: TypedField<"id", QueueEntryId, {}>;
+      sortIndex: TypedField<"int", number, {
+        readonly optional: true;
+      }>;
+      userId: TypedField<"belongsTo", UserId, {}>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      card: RelationEntry<"card", {
+        readonly type: "belongsTo";
+        readonly fk: "cardId";
+      }>;
+      user: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "userId";
+      }>;
+    }, ["id"]>;
+    release: ModelDesc<"release", {
+      content: TypedField<"string", string, {}>;
+      createdAt: TypedField<"date", Date, {}>;
+      id: TypedField<"id", ReleaseId, {}>;
+      title: TypedField<"string", string, {}>;
+      version: TypedField<"string", string, {}>;
+    }, {}, ["id"]>;
+    resolvable: ModelDesc<"resolvable", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      cardId: TypedField<"belongsTo", CardId, {}>;
+      closedAt: TypedField<"date", Date, {
+        readonly optional: true;
+      }>;
+      context: TypedField<"typed", (string & {}) | "review" | "block" | "comment", {}>;
+      createdAt: TypedField<"date", Date, {}>;
+      creatorId: TypedField<"belongsTo", UserId, {}>;
+      id: TypedField<"id", ResolvableId, {}>;
+      isClosed: TypedField<"bool", boolean, {}>;
+      reopenedAt: TypedField<"date", Date, {
+        readonly optional: true;
+      }>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      card: RelationEntry<"card", {
+        readonly type: "belongsTo";
+        readonly fk: "cardId";
+      }>;
+      closedBy: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly optional: true;
+      }>;
+      creator: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "creatorId";
+      }>;
+      entries: RelationEntry<"resolvableEntry", {
+        readonly type: "hasMany";
+      }>;
+      reopenedBy: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly optional: true;
+      }>;
+    }, ["id"]>;
+    resolvableEntry: ModelDesc<"resolvableEntry", {
+      authorId: TypedField<"belongsTo", UserId, {}>;
+      cardId: TypedField<"belongsTo", CardId, {}>;
+      content: TypedField<"string", string, {}>;
+      createdAt: TypedField<"date", Date, {}>;
+      entryId: TypedField<"id", ResolvableEntryId, {}>;
+      lastChangedAt: TypedField<"date", Date, {}>;
+      resolvableId: TypedField<"belongsTo", ResolvableId, {}>;
+      version: TypedField<"int", number, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      author: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "authorId";
+      }>;
+      card: RelationEntry<"card", {
+        readonly type: "belongsTo";
+        readonly fk: "cardId";
+      }>;
+      reactions: RelationEntry<"resolvableEntryReaction", {
+        readonly type: "hasMany";
+        readonly stability: "preview";
+      }>;
+      resolvable: RelationEntry<"resolvable", {
+        readonly type: "belongsTo";
+        readonly fk: "resolvableId";
+      }>;
+    }, ["entryId"]>;
+    resolvableEntryReaction: ModelDesc<"resolvableEntryReaction", {
+      accountId: TypedField<"belongsTo", AccountId, {
+        readonly stability: "preview";
+      }>;
+      createdAt: TypedField<"date", Date, {
+        readonly stability: "preview";
+      }>;
+      entryId: TypedField<"belongsTo", ResolvableEntryId, {
+        readonly stability: "preview";
+      }>;
+      id: TypedField<"id", ResolvableEntryReactionId, {}>;
+      resolvableId: TypedField<"belongsTo", ResolvableId, {
+        readonly stability: "preview";
+      }>;
+      userId: TypedField<"belongsTo", UserId, {
+        readonly stability: "preview";
+      }>;
+      value: TypedField<"typed", {
+        type: "emoji" | (string & {});
+        value: string;
+      }, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+        readonly stability: "preview";
+      }>;
+      resolvable: RelationEntry<"resolvable", {
+        readonly type: "belongsTo";
+        readonly fk: "resolvableId";
+        readonly stability: "preview";
+      }>;
+      resolvableEntry: RelationEntry<"resolvableEntry", {
+        readonly type: "belongsTo";
+        readonly fk: "entryId";
+        readonly stability: "preview";
+      }>;
+      user: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "userId";
+        readonly stability: "preview";
+      }>;
+    }, ["id"]>;
+    sprint: ModelDesc<"sprint", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      accountSeq: TypedField<"int", number, {}>;
+      autoMilestoneId: TypedField<"belongsTo", MilestoneId, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      completedAt: TypedField<"date", Date, {
+        readonly optional: true;
+      }>;
+      coverFileId: TypedField<"belongsTo", FileId, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      createdAt: TypedField<"date", Date, {}>;
+      description: TypedField<"string", string, {
+        readonly optional: true;
+      }>;
+      endDate: TypedField<"day", {
+        day: number;
+        month: number;
+        year: number;
+      }, {}>;
+      handSyncEnabled: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      id: TypedField<"id", SprintId, {}>;
+      index: TypedField<"int", number, {}>;
+      isDeleted: TypedField<"bool", boolean, {}>;
+      lockedAt: TypedField<"date", Date, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      manualOrderLabels: TypedField<"typed", (string | null)[], {
+        readonly stability: "preview";
+      }>;
+      name: TypedField<"string", string, {
+        readonly optional: true;
+      }>;
+      sprintConfigId: TypedField<"belongsTo", SprintConfigId, {}>;
+      startDate: TypedField<"day", {
+        day: number;
+        month: number;
+        year: number;
+      }, {}>;
+      userCapacities: TypedField<"typed", {
+        [userId: UserId]: number;
+      }, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      autoMilestone: RelationEntry<"milestone", {
+        readonly type: "belongsTo";
+        readonly fk: "autoMilestoneId";
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      cards: RelationEntry<"card", {
+        readonly type: "hasMany";
+      }>;
+      coverFile: RelationEntry<"file", {
+        readonly type: "belongsTo";
+        readonly fk: "coverFileId";
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      progress: RelationEntry<"sprintProgress", {
+        readonly type: "hasMany";
+        readonly stability: "preview";
+      }>;
+      sprintConfig: RelationEntry<"sprintConfig", {
+        readonly type: "belongsTo";
+        readonly fk: "sprintConfigId";
+      }>;
+    }, ["id"]>;
+    sprintConfig: ModelDesc<"sprintConfig", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      autoAssignNewCard: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      autoAssignStartedCard: TypedField<"bool", boolean, {
+        readonly stability: "preview";
+      }>;
+      autoBeastModeDurationHours: TypedField<"int", number, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      beastGracePeriodHours: TypedField<"int", number, {
+        readonly stability: "preview";
+      }>;
+      color: TypedField<"typed", MilestoneColor, {}>;
+      createdAt: TypedField<"date", Date, {}>;
+      creatorId: TypedField<"belongsTo", UserId, {}>;
+      id: TypedField<"id", SprintConfigId, {}>;
+      isGlobal: TypedField<"bool", boolean, {}>;
+      moveOnFinish: TypedField<"typed", ((string & {}) | "blocked" | "review" | "undone")[], {
+        readonly stability: "preview";
+      }>;
+      name: TypedField<"string", string, {}>;
+      runLabelTemplate: TypedField<"string", string, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      creator: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "creatorId";
+      }>;
+      progress: RelationEntry<"sprintConfigProgress", {
+        readonly type: "hasMany";
+        readonly stability: "preview";
+      }>;
+      sprintProjects: RelationEntry<"sprintProject", {
+        readonly type: "hasMany";
+      }>;
+      sprints: RelationEntry<"sprint", {
+        readonly type: "hasMany";
+      }>;
+    }, ["id"]>;
+    sprintConfigProgress: ModelDesc<"sprintConfigProgress", {
+      date: TypedField<"string", string, {
+        readonly stability: "preview";
+      }>;
+      progress: TypedField<"typed", unknown, {
+        readonly stability: "preview";
+      }>;
+      sprintConfigId: TypedField<"belongsTo", SprintConfigId, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      sprintConfig: RelationEntry<"sprintConfig", {
+        readonly type: "belongsTo";
+        readonly fk: "sprintConfigId";
+        readonly stability: "preview";
+      }>;
+    }, ["sprintConfigId", "date"]>;
+    sprintProgress: ModelDesc<"sprintProgress", {
+      date: TypedField<"string", string, {
+        readonly stability: "preview";
+      }>;
+      progress: TypedField<"typed", unknown, {
+        readonly stability: "preview";
+      }>;
+      sprintId: TypedField<"belongsTo", SprintId, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      sprint: RelationEntry<"sprint", {
+        readonly type: "belongsTo";
+        readonly fk: "sprintId";
+        readonly stability: "preview";
+      }>;
+    }, ["sprintId", "date"]>;
+    sprintProject: ModelDesc<"sprintProject", {
+      accountId: TypedField<"belongsTo", AccountId, {}>;
+      projectId: TypedField<"belongsTo", ProjectId, {}>;
+      sprintConfigId: TypedField<"belongsTo", SprintConfigId, {}>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+      }>;
+      project: RelationEntry<"project", {
+        readonly type: "belongsTo";
+        readonly fk: "projectId";
+      }>;
+      sprintConfig: RelationEntry<"sprintConfig", {
+        readonly type: "belongsTo";
+        readonly fk: "sprintConfigId";
+      }>;
+    }, ["sprintConfigId", "projectId"]>;
+    user: ModelDesc<"user", {
+      fullName: TypedField<"string", string, {
+        readonly optional: true;
+      }>;
+      id: TypedField<"id", UserId, {}>;
+      isIntegration: TypedField<"bool", boolean, {}>;
+      kind: TypedField<"typed", (string & {}) | "human" | "integration" | "api_token", {}>;
+      name: TypedField<"string", string, {}>;
+      profileImageId: TypedField<"belongsTo", FileId, {
+        readonly optional: true;
+      }>;
+      timezone: TypedField<"string", string, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+    }, {
+      profileImage: RelationEntry<"file", {
+        readonly type: "belongsTo";
+        readonly fk: "profileImageId";
+        readonly optional: true;
+      }>;
+    }, ["id"]>;
+    workflowItem: ModelDesc<"workflowItem", {
+      accountId: TypedField<"belongsTo", AccountId, {
+        readonly stability: "preview";
+      }>;
+      accountSeq: TypedField<"int", number, {
+        readonly stability: "preview";
+      }>;
+      assigneeId: TypedField<"belongsTo", UserId, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      checkboxInfo: TypedField<"typed", Checkbox[], {
+        readonly stability: "preview";
+      }>;
+      checkboxStats: TypedField<"typed", CheckboxStats, {
+        readonly stability: "preview";
+      }>;
+      content: TypedField<"string", string, {
+        readonly stability: "preview";
+      }>;
+      createdAt: TypedField<"date", Date, {
+        readonly stability: "preview";
+      }>;
+      creatorId: TypedField<"belongsTo", UserId, {
+        readonly stability: "preview";
+      }>;
+      deckId: TypedField<"belongsTo", DeckId, {
+        readonly stability: "preview";
+      }>;
+      effort: TypedField<"int", number, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      itemId: TypedField<"id", WorkflowItemId, {}>;
+      label: TypedField<"string", string, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      lastUpdatedAt: TypedField<"date", Date, {
+        readonly stability: "preview";
+      }>;
+      masterTags: TypedField<"typed", string[], {
+        readonly stability: "preview";
+      }>;
+      mentionedUsers: TypedField<"typed", UserId[], {
+        readonly stability: "preview";
+      }>;
+      priority: TypedField<"typed", Priority, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      sortValue: TypedField<"string", string, {
+        readonly stability: "preview";
+      }>;
+      tags: TypedField<"typed", string[], {
+        readonly stability: "preview";
+      }>;
+      targetDeckId: TypedField<"belongsTo", DeckId, {
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      title: TypedField<"string", string, {
+        readonly stability: "preview";
+      }>;
+      version: TypedField<"int", number, {
+        readonly stability: "preview";
+      }>;
+      visibility: TypedField<"typed", CardVisibility, {
+        readonly stability: "preview";
+      }>;
+    }, {
+      account: RelationEntry<"account", {
+        readonly type: "belongsTo";
+        readonly fk: "accountId";
+        readonly stability: "preview";
+      }>;
+      assignee: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "assigneeId";
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+      creator: RelationEntry<"user", {
+        readonly type: "belongsTo";
+        readonly fk: "creatorId";
+        readonly stability: "preview";
+      }>;
+      deck: RelationEntry<"deck", {
+        readonly type: "belongsTo";
+        readonly fk: "deckId";
+        readonly stability: "preview";
+      }>;
+      inDeps: RelationEntry<"workflowItem", {
+        readonly type: "hasMany";
+        readonly fkAsArray: true;
+        readonly stability: "preview";
+      }>;
+      outDeps: RelationEntry<"workflowItem", {
+        readonly type: "hasMany";
+        readonly fkAsArray: true;
+        readonly stability: "preview";
+      }>;
+      targetDeck: RelationEntry<"deck", {
+        readonly type: "belongsTo";
+        readonly fk: "targetDeckId";
+        readonly optional: true;
+        readonly stability: "preview";
+      }>;
+    }, ["itemId"]>;
+  };
+  requestedRelationKeys: Map<string, QueryDep>;
+  constructor(loader: BaseLoader);
+  subscribeToField(fieldKey: string, notifyFn: () => void): () => void;
+  invalidate(partKeyPatterns: string[]): void;
+  loadData(model: keyof ModelMap, ids: string[], q: ModelQuery<any, any>, acceptDirty?: boolean, iteration?: number): LoaderResult;
+  onLoaded(model: string, key: string, partialInstance: Record<string, unknown>): void;
+  /**
+   * Recursively check if query data is in cache
+   * Accumulates missing requests in the missingRequests array
+   */
+  private checkQueryRecursive;
+  /**
+   * Execute a mutation with optimistic updates
+   *
+   * @example
+   * ```typescript
+   * await store.mutate(
+   *   () => api.updateCard('123', {title: 'New Title'}),
+   *   {
+   *     onMutate: (layer) => {
+   *       layer.setField('Card', '123', 'title', 'New Title');
+   *     },
+   *     onSuccess: () => {
+   *       // Optional: invalidate related queries
+   *       store.invalidate(['Card:123:title']);
+   *     }
+   *   }
+   * );
+   * ```
+   */
+  mutate<T>(mutationFn: () => Promise<T>, options?: {
+    onMutate?: (updater: OptimisticUpdater) => void;
+    onSuccess?: (data: T) => void;
+    onError?: (error: unknown) => void;
+  }): Promise<T>;
+}
+//#endregion
+export { Store };