houdini 0.18.2 → 0.19.0

package/build/runtime/public/tests/test.d.ts

@@ -0,0 +1,114 @@
+import { Cache } from '../cache';
+import { Record } from '../record';
+type CacheTypeDef = {
+    types: {
+        __ROOT__: {
+            idFields: {};
+            fields: {
+                test: {
+                    type: number | null;
+                    args: never;
+                };
+                testDate: {
+                    type: Date;
+                    args: never;
+                };
+                viewer: {
+                    type: Record<CacheTypeDef, 'User'> | null;
+                    args: never;
+                };
+                pets: {
+                    type: (Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'>)[];
+                    args: never;
+                };
+                listOfLists: {
+                    type: ((Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'> | null | (null | Record<CacheTypeDef, 'User'>)[])[] | Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'> | null)[];
+                    args: never;
+                };
+                users: {
+                    type: Record<CacheTypeDef, 'User'>[] | null;
+                    args: never;
+                };
+                pet: {
+                    type: Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'>;
+                    args: never;
+                };
+            };
+        };
+        User: {
+            idFields: {
+                id: string;
+            };
+            fields: {
+                firstName: {
+                    type: string;
+                    args: never;
+                };
+                parent: {
+                    type: Record<CacheTypeDef, 'User'>;
+                    args: never;
+                };
+                id: {
+                    type: string;
+                    args: never;
+                };
+                __typename: {
+                    type: string;
+                    args: never;
+                };
+            };
+        };
+        Cat: {
+            idFields: {
+                id: string;
+            };
+            fields: {
+                name: {
+                    type: string | null;
+                    args: never;
+                };
+                parent: {
+                    type: Record<CacheTypeDef, 'User'> | null;
+                    args: never;
+                };
+                id: {
+                    type: string;
+                    args: never;
+                };
+                __typename: {
+                    type: string;
+                    args: never;
+                };
+            };
+        };
+        Ghost: {
+            idFields: {
+                id: string;
+            };
+            fields: {
+                name: {
+                    type: string | null;
+                    args: never;
+                };
+                __typename: {
+                    type: string;
+                    args: never;
+                };
+            };
+        };
+    };
+    lists: {
+        All_Pets: {
+            types: 'User' | 'Cat';
+            filters: never;
+        };
+        All_Users: {
+            types: 'User';
+            filters: {
+                foo?: string;
+            };
+        };
+    };
+};
+export declare const testCache: () => Cache<CacheTypeDef>;
+export {};

package/build/runtime/public/types.d.ts

@@ -0,0 +1,36 @@
+import type { Record } from './record';
+export type CacheTypeDef = {
+    types: {
+        [typeName: string]: {
+            idFields: {
+                [fieldName: string]: any;
+            };
+            fields: {
+                [fieldName: string]: {
+                    args: any;
+                    type: any;
+                };
+            };
+        };
+    };
+    lists: {
+        [listName: string]: {
+            types: any;
+            filters: any;
+        };
+    };
+};
+export type ValidTypes<Def extends CacheTypeDef> = keyof Def['types'];
+export type TypeFields<Def extends CacheTypeDef, Type extends keyof Def['types']> = Def['types'][Type]['fields'];
+export type TypeFieldNames<Def extends CacheTypeDef, Type extends keyof Def['types']> = Extract<keyof TypeFields<Def, Type>, string>;
+export type TypeNames<Def extends CacheTypeDef> = Extract<Exclude<ValidTypes<Def>, '__ROOT__'>, string>;
+export type IDFields<Def extends CacheTypeDef, Type extends keyof Def['types']> = Def['types'][Type]['idFields'];
+export type ProxyUnion<Def extends CacheTypeDef, U> = U extends null ? null : U extends TypeNames<Def> ? Record<Def, U> : never;
+export type FieldType<Def extends CacheTypeDef, Type extends keyof Def['types'], Field extends keyof TypeFields<Def, Type>> = TypeFields<Def, Type>[Field]['type'];
+export type ArgType<Def extends CacheTypeDef, Type extends keyof Def['types'], Field extends keyof TypeFields<Def, Type>> = TypeFields<Def, Type>[Field]['args'];
+export type ValidLists<Def extends CacheTypeDef> = Extract<keyof Def['lists'], string>;
+export type ListFilters<Def extends CacheTypeDef, ListName extends ValidLists<Def>> = Def['lists'][ListName]['filters'] extends any ? {
+    must?: Def['lists'][ListName]['filters'];
+    must_not?: Def['lists'][ListName]['filters'];
+} : never;
+export type ListType<Def extends CacheTypeDef, Name extends ValidLists<Def>> = ProxyUnion<Def, Def['lists'][Name]['types']>;

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

@@ -2,6 +2,7 @@ import { ConfigFile } from '../lib/config';
 import { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
 import { GarbageCollector } from './gc';
 import { ListCollection, ListManager } from './lists';
+import { SchemaManager } from './schema';
 import { InMemoryStorage, Layer, LayerID } from './storage';
 import { InMemorySubscriptions } from './subscription';
 export declare class Cache {
@@ -37,15 +38,17 @@ declare class CacheInternal {
     lists: ListManager;
     cache: Cache;
     lifetimes: GarbageCollector;
-    constructor({ storage, subscriptions, lists, cache, lifetimes, }: {
+    schema: SchemaManager;
+    constructor({ storage, subscriptions, lists, cache, lifetimes, schema, }: {
         storage: InMemoryStorage;
         subscriptions: InMemorySubscriptions;
         lists: ListManager;
         cache: Cache;
         lifetimes: GarbageCollector;
+        schema: SchemaManager;
     });
     setConfig(config: ConfigFile): void;
-    writeSelection({ data, selection, variables, root, parent, applyUpdates, layer, toNotify, forceNotify, }: {
+    writeSelection({ data, selection, variables, parent, applyUpdates, layer, toNotify, forceNotify, }: {
         data: {
             [key: string]: GraphQLValue;
         };

package/build/runtime-cjs/cache/cache.js

@@ -27,6 +27,7 @@ var import_deepEquals = require("../lib/deepEquals");
 var import_selection = require("../lib/selection");
 var import_gc = require("./gc");
 var import_lists = require("./lists");
+var import_schema = require("./schema");
 var import_storage = require("./storage");
 var import_stuff = require("./stuff");
 var import_subscription = require("./subscription");
@@ -38,7 +39,8 @@ class Cache {
       storage: new import_storage.InMemoryStorage(),
       subscriptions: new import_subscription.InMemorySubscriptions(this),
       lists: new import_lists.ListManager(this, rootID),
-      lifetimes: new import_gc.GarbageCollector(this)
+      lifetimes: new import_gc.GarbageCollector(this),
+      schema: new import_schema.SchemaManager(this)
     });
     if (config) {
       this.setConfig((0, import_config.defaultConfigValues)(config));
@@ -124,18 +126,21 @@ class CacheInternal {
   lists;
   cache;
   lifetimes;
+  schema;
   constructor({
     storage,
     subscriptions,
     lists,
     cache,
-    lifetimes
+    lifetimes,
+    schema
   }) {
     this.storage = storage;
     this.subscriptions = subscriptions;
     this.lists = lists;
     this.cache = cache;
     this.lifetimes = lifetimes;
+    this.schema = schema;
     this._disabled = typeof globalThis.window === "undefined";
     try {
       if (process.env.HOUDINI_TEST === "true") {
@@ -151,7 +156,6 @@ class CacheInternal {
     data,
     selection,
     variables = {},
-    root = rootID,
     parent = rootID,
     applyUpdates = false,
     layer,
@@ -174,9 +178,17 @@ class CacheInternal {
         selection: fieldSelection,
         operations,
         abstract: isAbstract,
-        update
+        update,
+        nullable
       } = targetSelection[field];
       const key = (0, import_stuff.evaluateKey)(keyRaw, variables);
+      this.schema.setFieldType({
+        parent,
+        key: keyRaw,
+        type: linkedType,
+        nullable,
+        link: !!fieldSelection
+      });
       const currentSubscribers = this.subscriptions.get(parent, key);
       const { value: previousValue, displayLayers } = this.storage.get(parent, key);
       const displayLayer = layer.isDisplayLayer(displayLayers);
@@ -245,7 +257,6 @@ class CacheInternal {
         }
         if (linkedID) {
           this.writeSelection({
-            root,
             selection: fieldSelection,
             parent: linkedID,
             data: value,

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

@@ -0,0 +1,21 @@
+import { ConfigFile } from '../lib';
+import { Cache } from './cache';
+export type TypeInfo = {
+    type: string;
+    nullable: boolean;
+    link: boolean;
+};
+export declare class SchemaManager {
+    cache: Cache;
+    fieldTypes: Record<string, Record<string, TypeInfo>>;
+    constructor(cache: Cache);
+    setFieldType({ parent, key, type, nullable, link, }: {
+        parent: string;
+        key: string;
+        type: string;
+        nullable?: boolean;
+        link?: boolean;
+    }): void;
+    fieldType(type: string, field: string): TypeInfo;
+    get config(): ConfigFile;
+}

package/build/runtime-cjs/cache/schema.js

@@ -0,0 +1,66 @@
+"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 schema_exports = {};
+__export(schema_exports, {
+  SchemaManager: () => SchemaManager
+});
+module.exports = __toCommonJS(schema_exports);
+var import_cache = require("./cache");
+class SchemaManager {
+  cache;
+  fieldTypes = {};
+  constructor(cache) {
+    this.cache = cache;
+  }
+  setFieldType({
+    parent,
+    key,
+    type,
+    nullable = false,
+    link
+  }) {
+    let parensIndex = key.indexOf("(");
+    if (parensIndex !== -1) {
+      key = key.substring(0, parensIndex);
+    }
+    if (parent === import_cache.rootID) {
+      parent = "Query";
+    } else if (parent.includes(":")) {
+      parent = parent.substring(0, parent.indexOf(":"));
+    }
+    if (!this.fieldTypes[parent]) {
+      this.fieldTypes[parent] = {};
+    }
+    this.fieldTypes[parent][key] = {
+      type,
+      nullable,
+      link: !!link
+    };
+  }
+  fieldType(type, field) {
+    return this.fieldTypes[type]?.[field] || null;
+  }
+  get config() {
+    return this.cache._internal_unstable.config;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SchemaManager
+});

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

@@ -0,0 +1,4 @@
+export type CacheTypeDef = {
+    types: {};
+    lists: {};
+};

package/build/runtime-cjs/generated.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 generated_exports = {};
+module.exports = __toCommonJS(generated_exports);

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

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

package/build/runtime-cjs/index.js

@@ -25,11 +25,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var runtime_exports = {};
 __export(runtime_exports, {
+  cache: () => cache,
   getCache: () => getCache,
   graphql: () => graphql
 });
 module.exports = __toCommonJS(runtime_exports);
 var import_cache = __toESM(require("./cache"), 1);
+var import_public = require("./public");
 __reExport(runtime_exports, require("./lib"), module.exports);
 function graphql(str) {
   if (globalThis?.process?.env?.HOUDINI_PLUGIN) {
@@ -40,11 +42,13 @@ function graphql(str) {
 Please make sure you have the appropriate plugin/preprocessor enabled. For more information, visit this link: https://houdinigraphql.com/guides/setting-up-your-project
 `);
 }
+const cache = new import_public.Cache(import_cache.default);
 function getCache() {
   return import_cache.default;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  cache,
   getCache,
   graphql
 });

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { GraphQLSchema } from 'graphql';
 import { CachePolicy } from './types';
 export declare function getMockConfig(): ConfigFile | null;
@@ -35,7 +34,7 @@ export type ConfigFile = {
     /**
      * A url to use to pull the schema. For more information: https://www.houdinigraphql.com/api/cli#generate
      */
-    apiUrl?: string;
+    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
      */
@@ -104,7 +103,7 @@ export type ConfigFile = {
      * directly. If the value is a function, the current environment will be passed to your function so you can perform any
      * logic you need
      */
-    schemaPollHeaders?: Record<string, string | ((env: NodeJS.ProcessEnv) => string)>;
+    schemaPollHeaders?: Record<string, string | ((env: Record<string, string | undefined>) => string)> | ((env: Record<string, string | undefined>) => Record<string, string>);
     /**
      * An object describing the plugins enabled for the project
      */
@@ -114,6 +113,11 @@ export type ConfigFile = {
      * @default process.cwd()
      */
     projectDir?: string;
+    /**
+     * For now, the cache's imperative API is considered unstable. In order to suppress the warning,
+     * you must enable this flag.
+     */
+    acceptImperativeInstability?: boolean;
 };
 type ScalarMap = {
     [typeName: string]: ScalarSpec;
@@ -121,7 +125,7 @@ type ScalarMap = {
 export type TypeConfig = {
     [typeName: string]: {
         keys?: string[];
-        resolve: {
+        resolve?: {
             queryField: string;
             arguments?: (data: any) => {
                 [key: string]: any;

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

@@ -4,7 +4,7 @@ import { CachePolicy, GraphQLObject, MutationArtifact, QueryArtifact, FetchQuery
 export declare class HoudiniClient {
     private fetchFn;
     socket: SubscriptionHandler | null | undefined;
-    constructor(networkFn: RequestHandler<any>, subscriptionHandler?: SubscriptionHandler | null);
+    constructor(requestHandler: RequestHandler<any>, subscriptionHandler?: SubscriptionHandler | null);
     handleMultipart(params: FetchParams, args: Parameters<FetchContext['fetch']>): Parameters<FetchContext['fetch']> | undefined;
     sendRequest<_Data>(ctx: FetchContext, params: FetchParams): Promise<RequestPayloadMagic<_Data>>;
 }
@@ -53,7 +53,7 @@ export type FetchContext = {
 export type RequestHandlerArgs = FetchContext & FetchParams & {
     session?: App.Session;
 };
-export type RequestHandler<_Data> = (args: RequestHandlerArgs) => Promise<RequestPayload<_Data>>;
+export type RequestHandler<_Data = any> = (args: RequestHandlerArgs) => Promise<RequestPayload<_Data>>;
 export declare function executeQuery<_Data extends GraphQLObject, _Input extends {}>({ client, artifact, variables, session, setFetching, cached, fetch, metadata, }: {
     client: HoudiniClient;
     artifact: QueryArtifact | MutationArtifact;

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

@@ -37,8 +37,8 @@ var import_types = require("./types");
 class HoudiniClient {
   fetchFn;
   socket;
-  constructor(networkFn, subscriptionHandler) {
-    this.fetchFn = networkFn;
+  constructor(requestHandler, subscriptionHandler) {
+    this.fetchFn = requestHandler;
     this.socket = subscriptionHandler;
   }
   handleMultipart(params, args) {

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

@@ -161,10 +161,10 @@ export type QueryResult<_Data, _Input, _Extra = {}> = {
     variables: _Input;
 } & _Extra;
 export type RequestPayload<_Data = any> = {
-    data: _Data;
+    data: _Data | null;
     errors: {
         message: string;
-    }[];
+    }[] | null;
 };
 export type RequestPayloadMagic<_Data = any> = {
     ssr: boolean;

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

@@ -0,0 +1,19 @@
+import { Cache as _Cache } from '../cache/cache';
+import { SchemaManager, TypeInfo } from '../cache/schema';
+import { ListCollection } from './list';
+import { Record } from './record';
+import type { CacheTypeDef, IDFields, 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;
+    list<Name extends ValidLists<Def>>(name: Name, { parentID, allLists }?: {
+        parentID?: string;
+        allLists?: boolean;
+    }): ListCollection<Def, Name>;
+}
+export declare function _typeInfo<Def extends CacheTypeDef>(cache: Cache<Def>, type: string, field: string): TypeInfo;

package/build/runtime-cjs/public/cache.js

@@ -0,0 +1,97 @@
+"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 cache_exports = {};
+__export(cache_exports, {
+  Cache: () => Cache,
+  _typeInfo: () => _typeInfo
+});
+module.exports = __toCommonJS(cache_exports);
+var import_cache = require("../cache/cache");
+var import_list = require("./list");
+var import_record = require("./record");
+class Cache {
+  _internal_unstable;
+  constructor(cache) {
+    this._internal_unstable = cache;
+  }
+  validateInstabilityWarning() {
+    if (!this.config.acceptImperativeInstability) {
+      console.warn(`\u26A0\uFE0F  The imperative cache API is considered unstable and will change in any minor version release
+Please acknowledge this by setting acceptImperativeInstability to true in your config file.`);
+    }
+  }
+  setFieldType(...args) {
+    this.validateInstabilityWarning();
+    this._internal_unstable._internal_unstable.schema.setFieldType(...args);
+  }
+  get root() {
+    this.validateInstabilityWarning();
+    return new import_record.Record({
+      cache: this,
+      type: "Query",
+      id: import_cache.rootID,
+      idFields: {}
+    });
+  }
+  get(type, data) {
+    this.validateInstabilityWarning();
+    let recordID = this._internal_unstable._internal_unstable.id(type, data);
+    if (!recordID) {
+      throw new Error("todo");
+    }
+    return new import_record.Record({
+      cache: this,
+      type,
+      id: recordID,
+      idFields: data
+    });
+  }
+  get config() {
+    return this._internal_unstable._internal_unstable.config;
+  }
+  list(name, { parentID, allLists } = {}) {
+    return new import_list.ListCollection({
+      cache: this,
+      name,
+      parentID,
+      allLists
+    });
+  }
+}
+function _typeInfo(cache, type, field) {
+  if (field === "__typename") {
+    return {
+      type: "String",
+      nullable: false,
+      link: false
+    };
+  }
+  const info = cache._internal_unstable._internal_unstable.schema.fieldType(type, field);
+  if (!info) {
+    throw new Error(
+      `Unknown field: ${field} for type ${type}. Please provide type information using setFieldType().`
+    );
+  }
+  return info;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cache,
+  _typeInfo
+});

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

@@ -0,0 +1 @@
+export { Cache } from './cache';

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

@@ -0,0 +1,28 @@
+"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 public_exports = {};
+__export(public_exports, {
+  Cache: () => import_cache.Cache
+});
+module.exports = __toCommonJS(public_exports);
+var import_cache = require("./cache");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cache
+});

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

@@ -0,0 +1,18 @@
+import { Cache } from './cache';
+import { CacheTypeDef, ListType, ValidLists, ListFilters } from './types';
+export declare class ListCollection<Def extends CacheTypeDef, ListName extends ValidLists<Def>> {
+    #private;
+    constructor({ parentID, allLists, when, cache, name, }: {
+        name: ValidLists<Def>;
+        parentID?: string;
+        allLists?: boolean;
+        when?: ListFilters<Def, ListName>;
+        cache: Cache<Def>;
+    });
+    append(...records: ListType<Def, ListName>[]): void;
+    prepend(...records: ListType<Def, ListName>[]): void;
+    toggle(where: 'first' | 'last', ...records: ListType<Def, ListName>[]): void;
+    when(filter: ListFilters<Def, ListName>): ListCollection<Def, ListName>;
+    remove(...records: ListType<Def, ListName>[]): void;
+    [Symbol.iterator](): Generator<string, void, unknown>;
+}