houdini 1.0.0-next.1 → 1.0.0-next.11

package/build/runtime-cjs/generated.d.ts

@@ -1,4 +1,5 @@
 export type CacheTypeDef = {
     types: {};
     lists: {};
+    queries: [];
 };

package/build/runtime-cjs/imports/config.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigFile } from '../lib/config';
+declare const _default: ConfigFile;
+export default _default;

package/build/runtime-cjs/imports/config.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  default: () => config_default
+});
+module.exports = __toCommonJS(config_exports);
+var config_default = {};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/build/runtime-cjs/index.d.ts

@@ -1,7 +1,8 @@
-import { Cache as InternalCache } from './cache/cache';
+import type { Cache as InternalCache } from './cache/cache';
 import type { CacheTypeDef } from './generated';
 import { Cache } from './public';
+export * from './client';
 export * from './lib';
-export declare function graphql(str: string | TemplateStringsArray): any;
+export declare function graphql<_Payload>(str: TemplateStringsArray): _Payload;
 export declare const cache: Cache<CacheTypeDef>;
 export declare function getCache(): InternalCache;

package/build/runtime-cjs/index.js

@@ -32,6 +32,7 @@ __export(runtime_exports, {
 module.exports = __toCommonJS(runtime_exports);
 var import_cache = __toESM(require("./cache"), 1);
 var import_public = require("./public");
+__reExport(runtime_exports, require("./client"), module.exports);
 __reExport(runtime_exports, require("./lib"), module.exports);
 function graphql(str) {
   if (globalThis?.process?.env?.HOUDINI_PLUGIN) {

package/build/runtime-cjs/lib/config.d.ts

@@ -1,11 +1,11 @@
-import { GraphQLSchema } from 'graphql';
-import { CachePolicy } from './types';
+import type { GraphQLSchema } from 'graphql';
+import type { CachePolicy } from './types';
 export declare function getMockConfig(): ConfigFile | null;
 export declare function setMockConfig(config: ConfigFile | null): void;
 export declare function defaultConfigValues(file: ConfigFile): ConfigFile;
 export declare function keyFieldsForType(configFile: ConfigFile, type: string): string[];
 export declare function computeID(configFile: ConfigFile, type: string, data: any): string;
-export declare function getCurrentConfig(): Promise<ConfigFile>;
+export declare function getCurrentConfig(): ConfigFile;
 export type ConfigFile = {
     /**
      * A glob pointing to all files that houdini should consider. Note, this must include .js files
@@ -31,10 +31,6 @@ export type ConfigFile = {
      * FYI: `schemaPath` or `schema` should be defined
      */
     schema?: string | GraphQLSchema;
-    /**
-     * A url to use to pull the schema. For more information: https://www.houdinigraphql.com/api/cli#generate
-     */
-    apiUrl?: string | ((env: Record<string, string | undefined>) => string);
     /**
      * An object describing custom scalars for your project. For more information: https://www.houdinigraphql.com/api/config#custom-scalars
      */
@@ -43,11 +39,6 @@ export type ConfigFile = {
      * A path that the generator will use to write schema.graphql and documents.gql files containing all of the internal fragment and directive definitions used in the project.
      */
     definitionsPath?: string;
-    /**
-     * One of "kit" or "svelte". Used to tell the preprocessor what kind of loading paradigm to generate for you. (default: `kit`)
-     * @deprecated please follow the steps here: http://www.houdinigraphql.com/guides/release-notes#0170
-     */
-    framework?: 'kit' | 'svelte';
     /**
      * One of "esm" or "commonjs". Tells the artifact generator what kind of modules to create. (default: `esm`)
      */
@@ -64,6 +55,10 @@ export type ConfigFile = {
      * Specifies whether or not the cache should always use partial data. For more information: https://www.houdinigraphql.com/guides/caching-data#partial-data
      */
     defaultPartial?: boolean;
+    /**
+     * Specifies after how long a data goes stale in miliseconds. (default: `undefined`)
+     */
+    defaultLifetime?: number;
     /**
      * Specifies whether mutations should append or prepend list. For more information: https://www.houdinigraphql.com/api/graphql (default: `append`)
      */
@@ -90,20 +85,9 @@ export type ConfigFile = {
      */
     defaultFragmentMasking?: 'enable' | 'disable';
     /**
-     * Configures the houdini plugin's schema polling behavior. By default, houdini will poll your APIs
-     * during development in order to keep it's definition of your schema up to date. The schemaPollingInterval
-     * config value sets the amount of time between each request in milliseconds (default 2 seconds).
-     * To limit the schema introspection to just on the start of the server, set schemaPollingInterval to 0.
-     * To disable the schema introspection, set schemaPollingInterval to null.
-     */
-    schemaPollInterval?: number | null;
-    /**
-     * An object containing the environment variables you want passed onto the api when polling for a new schema.
-     * The keys dictate the header names. If the value is a string, the corresponding environment variable will be used
-     * directly. If the value is a function, the current environment will be passed to your function so you can perform any
-     * logic you need
+     * Configure the dev environment to watch a remote schema for changes
      */
-    schemaPollHeaders?: Record<string, string | ((env: Record<string, string | undefined>) => string)> | ((env: Record<string, string | undefined>) => Record<string, string>);
+    watchSchema?: WatchSchemaConfig;
     /**
      * An object describing the plugins enabled for the project
      */
@@ -133,6 +117,25 @@ export type TypeConfig = {
         };
     };
 };
+export type WatchSchemaConfig = {
+    /**
+     * A url to use to pull the schema. For more information: https://www.houdinigraphql.com/api/cli#generate
+     */
+    url: string | ((env: Record<string, string | undefined>) => string);
+    /**
+     * sets the amount of time between each request in milliseconds (default 2 seconds).
+     * To limit the schema introspection to just on the start of the server, set interval to 0.
+     * To disable the schema introspection, set interval to null.
+     */
+    interval?: number | null;
+    /**
+     * An object containing the environment variables you want passed onto the api when polling for a new schema.
+     * The keys dictate the header names. If the value is a string, the corresponding environment variable will be used
+     * directly. If the value is a function, the current environment will be passed to your function so you can perform any
+     * logic you need
+     */
+    headers?: Record<string, string | ((env: Record<string, string | undefined>) => string)> | ((env: Record<string, string | undefined>) => Record<string, string>);
+};
 export type ScalarSpec = {
     type: string;
     marshal?: (val: any) => any;
@@ -140,4 +143,6 @@ export type ScalarSpec = {
 };
 export interface HoudiniPluginConfig {
 }
+export interface HoudiniClientPluginConfig {
+}
 export {};

package/build/runtime-cjs/lib/config.js

@@ -32,12 +32,13 @@ __export(config_exports, {
   setMockConfig: () => setMockConfig
 });
 module.exports = __toCommonJS(config_exports);
+var import_config = __toESM(require("../imports/config"), 1);
 let mockConfig = null;
 function getMockConfig() {
   return mockConfig;
 }
-function setMockConfig(config) {
-  mockConfig = config;
+function setMockConfig(config2) {
+  mockConfig = config2;
 }
 function defaultConfigValues(file) {
   return {
@@ -66,12 +67,12 @@ function computeID(configFile, type, data) {
   }
   return id.slice(0, -2);
 }
-async function getCurrentConfig() {
+function getCurrentConfig() {
   const mockConfig2 = getMockConfig();
   if (mockConfig2) {
     return mockConfig2;
   }
-  return defaultConfigValues((await import("HOUDINI_CONFIG_PATH")).default);
+  return defaultConfigValues(import_config.default);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/build/runtime-cjs/lib/flatten.d.ts

@@ -0,0 +1,2 @@
+import type { NestedList } from './types';
+export declare function flatten<T>(source?: NestedList<T>): T[];

package/build/runtime-cjs/lib/flatten.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var flatten_exports = {};
+__export(flatten_exports, {
+  flatten: () => flatten
+});
+module.exports = __toCommonJS(flatten_exports);
+function flatten(source) {
+  if (!source) {
+    return [];
+  }
+  return source.reduce((acc, element) => {
+    if (!element) {
+      return acc;
+    }
+    if (Array.isArray(element)) {
+      return acc.concat(flatten(element));
+    }
+    return acc.concat(element);
+  }, []);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flatten
+});

package/build/runtime-cjs/lib/index.d.ts

@@ -1,8 +1,8 @@
 export * from './config';
 export * from './constants';
 export * from './deepEquals';
-export * from './errors';
 export * from './log';
-export * from './network';
 export * from './scalars';
 export * from './types';
+export * from './store';
+export * from './key';

package/build/runtime-cjs/lib/index.js

@@ -18,8 +18,8 @@ module.exports = __toCommonJS(lib_exports);
 __reExport(lib_exports, require("./config"), module.exports);
 __reExport(lib_exports, require("./constants"), module.exports);
 __reExport(lib_exports, require("./deepEquals"), module.exports);
-__reExport(lib_exports, require("./errors"), module.exports);
 __reExport(lib_exports, require("./log"), module.exports);
-__reExport(lib_exports, require("./network"), module.exports);
 __reExport(lib_exports, require("./scalars"), module.exports);
 __reExport(lib_exports, require("./types"), module.exports);
+__reExport(lib_exports, require("./store"), module.exports);
+__reExport(lib_exports, require("./key"), module.exports);

package/build/runtime-cjs/lib/key.d.ts

@@ -0,0 +1,6 @@
+export declare const computeKey: ({ field, args }: {
+    field: string;
+    args?: {
+        [key: string]: any;
+    } | undefined;
+}) => string;

package/build/runtime-cjs/lib/key.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var key_exports = {};
+__export(key_exports, {
+  computeKey: () => computeKey
+});
+module.exports = __toCommonJS(key_exports);
+const computeKey = ({ field, args }) => {
+  const keys = Object.keys(args ?? {});
+  keys.sort();
+  return args && keys.length > 0 ? `${field}(${keys.map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(args[key])}`).join(", ")})` : field;
+};
+const stringifyObjectWithNoQuotesOnKeys = (obj_from_json) => {
+  if (Array.isArray(obj_from_json)) {
+    return `[${obj_from_json.map((obj) => `${stringifyObjectWithNoQuotesOnKeys(obj)}`).join(", ")}]`;
+  }
+  if (typeof obj_from_json !== "object" || obj_from_json instanceof Date || obj_from_json === null) {
+    return JSON.stringify(obj_from_json).replace(/"([^"]+)":/g, "$1: ");
+  }
+  return `{${Object.keys(obj_from_json).map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(obj_from_json[key])}`).join(", ")}}`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeKey
+});

package/build/runtime-cjs/lib/scalars.d.ts

@@ -1,14 +1,15 @@
-import { ConfigFile } from './config';
-import { MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
+import type { ConfigFile } from './config';
+import type { FragmentArtifact, MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
 export declare function marshalSelection({ selection, data, }: {
     selection: SubscriptionSelection;
     data: any;
 }): Promise<{} | null | undefined>;
-export declare function marshalInputs<T>({ artifact, input, rootType, }: {
-    artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact;
+export declare function marshalInputs<T>({ artifact, input, config, rootType, }: {
+    artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact | FragmentArtifact;
     input: unknown;
     rootType?: string;
-}): Promise<{} | null | undefined>;
+    config: ConfigFile;
+}): {} | null | undefined;
 export declare function unmarshalSelection(config: ConfigFile, selection: SubscriptionSelection, data: any): {} | null | undefined;
 export declare function isScalar(config: ConfigFile, type: string): boolean;
 export declare function parseScalar(config: ConfigFile, type: string, value: string): string | number | boolean;

package/build/runtime-cjs/lib/scalars.js

@@ -31,7 +31,7 @@ async function marshalSelection({
   selection,
   data
 }) {
-  const config = await (0, import_config.getCurrentConfig)();
+  const config = (0, import_config.getCurrentConfig)();
   if (data === null || typeof data === "undefined") {
     return data;
   }
@@ -66,12 +66,12 @@ async function marshalSelection({
     )
   );
 }
-async function marshalInputs({
+function marshalInputs({
   artifact,
   input,
+  config,
   rootType = "@root"
 }) {
-  const config = await (0, import_config.getCurrentConfig)();
   if (input === null || typeof input === "undefined") {
     return input;
   }
@@ -80,30 +80,26 @@ async function marshalInputs({
   }
   const fields = rootType === "@root" ? artifact.input.fields : artifact.input.types[rootType];
   if (Array.isArray(input)) {
-    return await Promise.all(
-      input.map(async (val) => await marshalInputs({ artifact, input: val, rootType }))
-    );
+    return input.map((val) => marshalInputs({ artifact, input: val, rootType, config }));
   }
   return Object.fromEntries(
-    await Promise.all(
-      Object.entries(input).map(async ([fieldName, value]) => {
-        const type = fields?.[fieldName];
-        if (!type) {
-          return [fieldName, value];
-        }
-        const marshalFn = config.scalars?.[type]?.marshal;
-        if (marshalFn) {
-          if (Array.isArray(value)) {
-            return [fieldName, value.map(marshalFn)];
-          }
-          return [fieldName, marshalFn(value)];
-        }
-        if (isScalar(config, type) || !artifact.input.types[type]) {
-          return [fieldName, value];
+    Object.entries(input).map(([fieldName, value]) => {
+      const type = fields?.[fieldName];
+      if (!type) {
+        return [fieldName, value];
+      }
+      const marshalFn = config.scalars?.[type]?.marshal;
+      if (marshalFn) {
+        if (Array.isArray(value)) {
+          return [fieldName, value.map(marshalFn)];
         }
-        return [fieldName, await marshalInputs({ artifact, input: value, rootType: type })];
-      })
-    )
+        return [fieldName, marshalFn(value)];
+      }
+      if (isScalar(config, type) || !artifact.input.types[type]) {
+        return [fieldName, value];
+      }
+      return [fieldName, marshalInputs({ artifact, input: value, rootType: type, config })];
+    })
   );
 }
 function unmarshalSelection(config, selection, data) {

package/build/runtime-cjs/lib/selection.d.ts

@@ -1,2 +1,2 @@
-import { SubscriptionSelection } from './types';
+import type { SubscriptionSelection } from './types';
 export declare function getFieldsForType(selection: SubscriptionSelection, __typename: string | undefined | null): Required<SubscriptionSelection>['fields'];

package/build/runtime-cjs/lib/store.d.ts

@@ -0,0 +1,19 @@
+export declare class Writable<T> {
+    #private;
+    state: T;
+    constructor(value: T, start?: StartStopNotifier<T>);
+    set(new_value: T): void;
+    update(fn: Updater<T>): void;
+    subscribe(run: Subscriber<T>, invalidate?: Invalidator<T>): Unsubscriber;
+}
+/** Start and stop notification callbacks. */
+type StartStopNotifier<T> = (set: Subscriber<T>) => Unsubscriber | void;
+/** Callback to inform of a value updates. */
+export type Subscriber<T> = (value: T) => void;
+/** Unsubscribes from value updates. */
+export type Unsubscriber = () => void;
+/** Callback to update a value. */
+type Updater<T> = (value: T) => T;
+/** Cleanup logic callback. */
+type Invalidator<T> = (value?: T) => void;
+export {};

package/build/runtime-cjs/lib/store.js

@@ -0,0 +1,81 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var store_exports = {};
+__export(store_exports, {
+  Writable: () => Writable
+});
+module.exports = __toCommonJS(store_exports);
+const subscriber_queue = [];
+const noop = () => {
+};
+class Writable {
+  state;
+  #subscribers;
+  #stop;
+  #start;
+  constructor(value, start = noop) {
+    this.state = value;
+    this.#subscribers = /* @__PURE__ */ new Set();
+    this.#stop = null;
+    this.#start = start;
+  }
+  set(new_value) {
+    if (safe_not_equal(this.state, new_value)) {
+      this.state = new_value;
+      if (this.#stop) {
+        const run_queue = !subscriber_queue.length;
+        for (const subscriber of this.#subscribers) {
+          subscriber[1]();
+          subscriber_queue.push(subscriber, this.state);
+        }
+        if (run_queue) {
+          for (let i = 0; i < subscriber_queue.length; i += 2) {
+            subscriber_queue[i][0](subscriber_queue[i + 1]);
+          }
+          subscriber_queue.length = 0;
+        }
+      }
+    }
+  }
+  update(fn) {
+    this.set(fn(this.state));
+  }
+  subscribe(run, invalidate = noop) {
+    const subscriber = [run, invalidate];
+    this.#subscribers.add(subscriber);
+    if (this.#subscribers.size === 1) {
+      this.#stop = this.#start(this.set) || noop;
+    }
+    run(this.state);
+    return () => {
+      this.#subscribers.delete(subscriber);
+      if (this.#subscribers.size === 0) {
+        this.#stop?.();
+        this.#stop = null;
+      }
+    };
+  }
+}
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Writable
+});

package/build/runtime-cjs/lib/types.d.ts

@@ -4,6 +4,22 @@ export declare enum CachePolicy {
     NetworkOnly = "NetworkOnly",
     CacheAndNetwork = "CacheAndNetwork"
 }
+declare global {
+    namespace App {
+        interface Session {
+        }
+        interface Metadata {
+        }
+        interface Stuff {
+            inputs: {
+                init: boolean;
+                marshaled: Record<string, any>;
+                changed: boolean;
+            };
+            optimisticResponse?: GraphQLObject;
+        }
+    }
+}
 export type Fragment<_Result> = {
     readonly shape?: _Result;
 };
@@ -55,7 +71,6 @@ export type BaseCompiledDocument = {
     rootType: string;
     input?: InputObject;
     refetch?: {
-        update: RefetchUpdateMode;
         path: string[];
         method: 'cursor' | 'offset';
         pageSize: number;
@@ -63,8 +78,9 @@ export type BaseCompiledDocument = {
         embedded: boolean;
         targetType: string;
         paginated: boolean;
-        direction?: 'forward' | 'backwards';
+        direction: 'forward' | 'backward' | 'both';
     };
+    plugin_data?: Record<string, any>;
 };
 export type HoudiniFetchContext = {
     variables: () => {};
@@ -118,7 +134,7 @@ export type SubscriptionSelection = {
                 connection: boolean;
                 type: string;
             };
-            update?: RefetchUpdateMode;
+            updates?: string[];
             filters?: {
                 [key: string]: {
                     kind: 'Boolean' | 'String' | 'Float' | 'Int' | 'Variable';
@@ -148,26 +164,24 @@ export type SubscriptionSpec = {
 export type FetchQueryResult<_Data> = {
     result: RequestPayload<_Data | null>;
     source: DataSource | null;
-    partial: boolean;
 };
-export type QueryResult<_Data, _Input, _Extra = {}> = {
+export type QueryResult<_Data = GraphQLObject, _Input = Record<string, any>> = {
     data: _Data | null;
     errors: {
         message: string;
     }[] | null;
     fetching: boolean;
     partial: boolean;
+    stale: boolean;
     source: DataSource | null;
-    variables: _Input;
-} & _Extra;
-export type RequestPayload<_Data = any> = {
-    data: _Data | null;
+    variables: _Input | null;
+};
+export type RequestPayload<GraphQLObject = any> = {
+    data: GraphQLObject | null;
     errors: {
         message: string;
     }[] | null;
 };
-export type RequestPayloadMagic<_Data = any> = {
-    ssr: boolean;
-    body: RequestPayload<_Data>;
-};
+export type NestedList<_Result = string> = (_Result | null | NestedList<_Result>)[];
+export type ValueOf<Parent> = Parent[keyof Parent];
 export {};

package/build/runtime-cjs/public/cache.d.ts

@@ -1,19 +1,39 @@
-import { Cache as _Cache } from '../cache/cache';
-import { SchemaManager, TypeInfo } from '../cache/schema';
+import type { Cache as _Cache } from '../cache/cache';
+import { type QueryArtifact } from '../lib';
 import { ListCollection } from './list';
 import { Record } from './record';
-import type { CacheTypeDef, IDFields, TypeNames, ValidLists } from './types';
+import type { ArgType, CacheTypeDef, IDFields, QueryInput, QueryList, QueryValue, TypeFieldNames, TypeNames, ValidLists } from './types';
 export declare class Cache<Def extends CacheTypeDef> {
     _internal_unstable: _Cache;
     constructor(cache: _Cache);
     validateInstabilityWarning(): void;
-    setFieldType(...args: Parameters<SchemaManager['setFieldType']>): void;
-    get root(): Record<Def, '__ROOT__'>;
     get<T extends TypeNames<Def>>(type: T, data: IDFields<Def, T>): Record<Def, T>;
-    get config(): import("..").ConfigFile;
+    get config(): import("../lib").ConfigFile;
     list<Name extends ValidLists<Def>>(name: Name, { parentID, allLists }?: {
         parentID?: string;
         allLists?: boolean;
     }): ListCollection<Def, Name>;
+    read<_Query extends {
+        artifact: QueryArtifact;
+    }>({ query, variables, }: {
+        query: _Query;
+        variables?: QueryInput<QueryList<Def>, _Query>;
+    }): {
+        data: QueryValue<QueryList<Def>, _Query> | null;
+        partial: boolean;
+    };
+    write<_Query extends {
+        artifact: QueryArtifact;
+    }>({ query, variables, data, }: {
+        query: _Query;
+        data: QueryValue<QueryList<Def>, _Query>;
+        variables?: QueryInput<QueryList<Def>, _Query>;
+    }): void;
+    /**
+     * Mark some elements of the cache stale.
+     */
+    markStale<_Type extends TypeNames<Def>, _Field extends TypeFieldNames<Def, _Type>>(type?: _Type, options?: {
+        field?: _Field;
+        when?: ArgType<Def, _Type, _Field>;
+    }): void;
 }
-export declare function _typeInfo<Def extends CacheTypeDef>(cache: Cache<Def>, type: string, field: string): TypeInfo;