@graphql-tools/mock 9.0.26-alpha-20251026055227-9bd9835d18cc3f0f03fa9cd7426372cdcd9cb85c → 9.1.0-alpha-20251027010606-226b580f6448e27f51c6c50b3035c631e1902460

package/cjs/MockStore.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockStore = exports.defaultMocks = void 0;
+exports.MockStore = void 0;
 exports.createMockStore = createMockStore;
 const tslib_1 = require("tslib");
 const fast_json_stable_stringify_1 = tslib_1.__importDefault(require("fast-json-stable-stringify"));
@@ -8,22 +8,35 @@ const graphql_1 = require("graphql");
 const MockList_js_1 = require("./MockList.js");
 const types_js_1 = require("./types.js");
 const utils_js_1 = require("./utils.js");
-exports.defaultMocks = {
+const defaultRandomMocks = {
     Int: () => Math.round(Math.random() * 200) - 100,
     Float: () => Math.random() * 200 - 100,
-    String: () => 'Hello World',
     Boolean: () => Math.random() > 0.5,
+};
+const defaultDeterministicMocks = {
+    Int: () => 1,
+    Float: () => 1.5,
+    Boolean: () => true,
+};
+const defaultCommonMocks = {
+    String: () => 'Hello World',
     ID: () => (0, utils_js_1.uuidv4)(),
 };
 const defaultKeyFieldNames = ['id', '_id'];
 class MockStore {
     schema;
     mocks;
+    mockGenerationBehavior;
     typePolicies;
     store = {};
-    constructor({ schema, mocks, typePolicies, }) {
+    constructor({ schema, mocks, mockGenerationBehavior = 'random', typePolicies, }) {
         this.schema = schema;
-        this.mocks = { ...exports.defaultMocks, ...mocks };
+        this.mockGenerationBehavior = mockGenerationBehavior;
+        this.mocks = {
+            ...defaultCommonMocks,
+            ...(mockGenerationBehavior === 'random' ? defaultRandomMocks : defaultDeterministicMocks),
+            ...mocks,
+        };
         this.typePolicies = typePolicies || {};
     }
     has(typeName, key) {
@@ -374,7 +387,7 @@ class MockStore {
             if (typeof mockFn === 'function')
                 return mockFn();
             const values = nullableType.getValues().map(v => v.value);
-            return (0, utils_js_1.takeRandom)(values);
+            return (0, utils_js_1.takeOneOf)(values, this.mockGenerationBehavior);
         }
         else if ((0, graphql_1.isObjectType)(nullableType)) {
             // this will create a new random ref
@@ -388,7 +401,7 @@ class MockStore {
             let typeName;
             let values = {};
             if (!mock) {
-                typeName = (0, utils_js_1.takeRandom)(this.schema.getPossibleTypes(nullableType).map(t => t.name));
+                typeName = (0, utils_js_1.takeOneOf)(this.schema.getPossibleTypes(nullableType).map(t => t.name), this.mockGenerationBehavior);
             }
             else if (typeof mock === 'function') {
                 const mockRes = mock();
@@ -490,6 +503,8 @@ function assertIsDefined(value, message) {
  * Will create `MockStore` for the given `schema`.
  *
  * A `MockStore` will generate mock values for the given schema when queried.
+ * By default it'll generate random values, if this causes flakiness and you
+ * need a more deterministic behavior, use `mockGenerationBehavior` option.
  *
  * It will store generated mocks, so that, provided with same arguments
  * the returned values will be the same.

package/cjs/addMocksToSchema.js

@@ -66,7 +66,7 @@ const utils_js_1 = require("./utils.js");
  *
  * `Query` and `Mutation` type will use `key` `'ROOT'`.
  */
-function addMocksToSchema({ schema, store: maybeStore, mocks, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers = false, }) {
+function addMocksToSchema({ schema, store: maybeStore, mocks, mockGenerationBehavior, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers = false, }) {
     if (!schema) {
         throw new Error('Must provide schema to mock');
     }
@@ -80,6 +80,7 @@ function addMocksToSchema({ schema, store: maybeStore, mocks, typePolicies, reso
         (0, MockStore_js_1.createMockStore)({
             schema,
             mocks,
+            mockGenerationBehavior,
             typePolicies,
         });
     const resolvers = typeof resolversOrFnResolvers === 'function'

package/cjs/mockServer.js

@@ -15,8 +15,10 @@ const addMocksToSchema_js_1 = require("./addMocksToSchema.js");
  * @param preserveResolvers Set to `true` to prevent existing resolvers from being
  * overwritten to provide mock data. This can be used to mock some parts of the
  * server and not others.
+ * @param mockGenerationBehavior Set to `'deterministic'` if the default random
+ * mock generation behavior causes flakiness.
  */
-function mockServer(schema, mocks, preserveResolvers = false) {
+function mockServer(schema, mocks, preserveResolvers = false, mockGenerationBehavior) {
     const mockedSchema = (0, addMocksToSchema_js_1.addMocksToSchema)({
         schema: (0, graphql_1.isSchema)(schema)
             ? schema
@@ -24,6 +26,7 @@ function mockServer(schema, mocks, preserveResolvers = false) {
                 typeDefs: schema,
             }),
         mocks,
+        mockGenerationBehavior,
         preserveResolvers,
     });
     return {

package/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRootType = exports.takeRandom = exports.randomListLength = void 0;
+exports.isRootType = exports.takeOneOf = exports.randomListLength = void 0;
 exports.uuidv4 = uuidv4;
 exports.makeRef = makeRef;
 exports.isObject = isObject;
@@ -21,8 +21,13 @@ const randomListLength = () => {
     return 2;
 };
 exports.randomListLength = randomListLength;
-const takeRandom = (arr) => arr[Math.floor(Math.random() * arr.length)];
-exports.takeRandom = takeRandom;
+const takeOneOf = (arr, behavior) => {
+    if (behavior === 'deterministic') {
+        return arr[0];
+    }
+    return arr[Math.floor(Math.random() * arr.length)];
+};
+exports.takeOneOf = takeOneOf;
 function makeRef(typeName, key) {
     return { $ref: { key, typeName } };
 }

package/esm/MockStore.js

@@ -2,23 +2,36 @@ import stringify from 'fast-json-stable-stringify';
 import { getNullableType, GraphQLString, isAbstractType, isCompositeType, isEnumType, isInterfaceType, isListType, isNonNullType, isObjectType, isScalarType, } from 'graphql';
 import { deepResolveMockList, isMockList } from './MockList.js';
 import { assertIsRef, isRecord, isRef, } from './types.js';
-import { makeRef, randomListLength, takeRandom, uuidv4 } from './utils.js';
-export const defaultMocks = {
+import { makeRef, randomListLength, takeOneOf, uuidv4 } from './utils.js';
+const defaultRandomMocks = {
     Int: () => Math.round(Math.random() * 200) - 100,
     Float: () => Math.random() * 200 - 100,
-    String: () => 'Hello World',
     Boolean: () => Math.random() > 0.5,
+};
+const defaultDeterministicMocks = {
+    Int: () => 1,
+    Float: () => 1.5,
+    Boolean: () => true,
+};
+const defaultCommonMocks = {
+    String: () => 'Hello World',
     ID: () => uuidv4(),
 };
 const defaultKeyFieldNames = ['id', '_id'];
 export class MockStore {
     schema;
     mocks;
+    mockGenerationBehavior;
     typePolicies;
     store = {};
-    constructor({ schema, mocks, typePolicies, }) {
+    constructor({ schema, mocks, mockGenerationBehavior = 'random', typePolicies, }) {
         this.schema = schema;
-        this.mocks = { ...defaultMocks, ...mocks };
+        this.mockGenerationBehavior = mockGenerationBehavior;
+        this.mocks = {
+            ...defaultCommonMocks,
+            ...(mockGenerationBehavior === 'random' ? defaultRandomMocks : defaultDeterministicMocks),
+            ...mocks,
+        };
         this.typePolicies = typePolicies || {};
     }
     has(typeName, key) {
@@ -369,7 +382,7 @@ export class MockStore {
             if (typeof mockFn === 'function')
                 return mockFn();
             const values = nullableType.getValues().map(v => v.value);
-            return takeRandom(values);
+            return takeOneOf(values, this.mockGenerationBehavior);
         }
         else if (isObjectType(nullableType)) {
             // this will create a new random ref
@@ -383,7 +396,7 @@ export class MockStore {
             let typeName;
             let values = {};
             if (!mock) {
-                typeName = takeRandom(this.schema.getPossibleTypes(nullableType).map(t => t.name));
+                typeName = takeOneOf(this.schema.getPossibleTypes(nullableType).map(t => t.name), this.mockGenerationBehavior);
             }
             else if (typeof mock === 'function') {
                 const mockRes = mock();
@@ -484,6 +497,8 @@ function assertIsDefined(value, message) {
  * Will create `MockStore` for the given `schema`.
  *
  * A `MockStore` will generate mock values for the given schema when queried.
+ * By default it'll generate random values, if this causes flakiness and you
+ * need a more deterministic behavior, use `mockGenerationBehavior` option.
  *
  * It will store generated mocks, so that, provided with same arguments
  * the returned values will be the same.

package/esm/addMocksToSchema.js

@@ -63,7 +63,7 @@ import { copyOwnProps, isObject, isRootType } from './utils.js';
  *
  * `Query` and `Mutation` type will use `key` `'ROOT'`.
  */
-export function addMocksToSchema({ schema, store: maybeStore, mocks, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers = false, }) {
+export function addMocksToSchema({ schema, store: maybeStore, mocks, mockGenerationBehavior, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers = false, }) {
     if (!schema) {
         throw new Error('Must provide schema to mock');
     }
@@ -77,6 +77,7 @@ export function addMocksToSchema({ schema, store: maybeStore, mocks, typePolicie
         createMockStore({
             schema,
             mocks,
+            mockGenerationBehavior,
             typePolicies,
         });
     const resolvers = typeof resolversOrFnResolvers === 'function'

package/esm/mockServer.js

@@ -12,8 +12,10 @@ import { addMocksToSchema } from './addMocksToSchema.js';
  * @param preserveResolvers Set to `true` to prevent existing resolvers from being
  * overwritten to provide mock data. This can be used to mock some parts of the
  * server and not others.
+ * @param mockGenerationBehavior Set to `'deterministic'` if the default random
+ * mock generation behavior causes flakiness.
  */
-export function mockServer(schema, mocks, preserveResolvers = false) {
+export function mockServer(schema, mocks, preserveResolvers = false, mockGenerationBehavior) {
     const mockedSchema = addMocksToSchema({
         schema: isSchema(schema)
             ? schema
@@ -21,6 +23,7 @@ export function mockServer(schema, mocks, preserveResolvers = false) {
                 typeDefs: schema,
             }),
         mocks,
+        mockGenerationBehavior,
         preserveResolvers,
     });
     return {

package/esm/utils.js

@@ -12,7 +12,12 @@ export const randomListLength = () => {
     // return 1 + Math.round(Math.random() * 10)
     return 2;
 };
-export const takeRandom = (arr) => arr[Math.floor(Math.random() * arr.length)];
+export const takeOneOf = (arr, behavior) => {
+    if (behavior === 'deterministic') {
+        return arr[0];
+    }
+    return arr[Math.floor(Math.random() * arr.length)];
+};
 export function makeRef(typeName, key) {
     return { $ref: { key, typeName } };
 }

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@graphql-tools/mock",
-  "version": "9.0.26-alpha-20251026055227-9bd9835d18cc3f0f03fa9cd7426372cdcd9cb85c",
+  "version": "9.1.0-alpha-20251027010606-226b580f6448e27f51c6c50b3035c631e1902460",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/schema": "10.0.26-alpha-20251026055227-9bd9835d18cc3f0f03fa9cd7426372cdcd9cb85c",
-    "@graphql-tools/utils": "10.10.0-alpha-20251026055227-9bd9835d18cc3f0f03fa9cd7426372cdcd9cb85c",
+    "@graphql-tools/schema": "10.0.26-alpha-20251027010606-226b580f6448e27f51c6c50b3035c631e1902460",
+    "@graphql-tools/utils": "10.10.0-alpha-20251027010606-226b580f6448e27f51c6c50b3035c631e1902460",
     "fast-json-stable-stringify": "^2.1.0",
     "tslib": "^2.4.0"
   },

package/typings/MockStore.d.cts

@@ -1,23 +1,18 @@
 import { GraphQLSchema } from 'graphql';
-import { GetArgs, IMocks, IMockStore, KeyTypeConstraints, Ref, SetArgs, TypePolicy } from './types.cjs';
-export declare const defaultMocks: {
-    Int: () => number;
-    Float: () => number;
-    String: () => string;
-    Boolean: () => boolean;
-    ID: () => string;
-};
+import { GetArgs, IMocks, IMockStore, KeyTypeConstraints, MockGenerationBehavior, Ref, SetArgs, TypePolicy } from './types.cjs';
 type Entity = {
     [key: string]: unknown;
 };
 export declare class MockStore implements IMockStore {
     schema: GraphQLSchema;
     private mocks;
+    private mockGenerationBehavior;
     private typePolicies;
     private store;
-    constructor({ schema, mocks, typePolicies, }: {
+    constructor({ schema, mocks, mockGenerationBehavior, typePolicies, }: {
         schema: GraphQLSchema;
         mocks?: IMocks;
+        mockGenerationBehavior?: MockGenerationBehavior;
         typePolicies?: {
             [typeName: string]: TypePolicy;
         };
@@ -57,6 +52,8 @@ export declare class MockStore implements IMockStore {
  * Will create `MockStore` for the given `schema`.
  *
  * A `MockStore` will generate mock values for the given schema when queried.
+ * By default it'll generate random values, if this causes flakiness and you
+ * need a more deterministic behavior, use `mockGenerationBehavior` option.
  *
  * It will store generated mocks, so that, provided with same arguments
  * the returned values will be the same.
@@ -87,6 +84,29 @@ export declare function createMockStore(options: {
      * The mocks functions to use.
      */
     mocks?: IMocks;
+    /**
+     * Configures the default behavior for Scalar, Enum, Union, and Array types.
+     *
+     * When set to `random`, then every time a value is generated for a field with
+     * one of these types
+     * - For Unions and Enums one of the allowed values will be picked randomly
+     * - For Arrays an array of random length will be generated
+     * - For Int and Float scalars a random number will be generated
+     * - For Boolean scalars either `true` or `false` will be returned randomly
+     *
+     * When set to `deterministic`, then
+     * - For Unions and Enums the first allowed value is picked
+     * - For Arrays an array of two elements will be generated
+     * - For Int and Float scalars values 1 and 1.5 will be used respectively
+     * - For Boolean scalars we'll always return `true`
+     * - For String scalars we'll always return "Hello World"
+     *
+     * Regardless of the chosen behavior, for ID scalars a random UUID string
+     * will always be generated.
+     *
+     * @default "random"
+     */
+    mockGenerationBehavior?: MockGenerationBehavior;
     typePolicies?: {
         [typeName: string]: TypePolicy;
     };

package/typings/MockStore.d.ts

@@ -1,23 +1,18 @@
 import { GraphQLSchema } from 'graphql';
-import { GetArgs, IMocks, IMockStore, KeyTypeConstraints, Ref, SetArgs, TypePolicy } from './types.js';
-export declare const defaultMocks: {
-    Int: () => number;
-    Float: () => number;
-    String: () => string;
-    Boolean: () => boolean;
-    ID: () => string;
-};
+import { GetArgs, IMocks, IMockStore, KeyTypeConstraints, MockGenerationBehavior, Ref, SetArgs, TypePolicy } from './types.js';
 type Entity = {
     [key: string]: unknown;
 };
 export declare class MockStore implements IMockStore {
     schema: GraphQLSchema;
     private mocks;
+    private mockGenerationBehavior;
     private typePolicies;
     private store;
-    constructor({ schema, mocks, typePolicies, }: {
+    constructor({ schema, mocks, mockGenerationBehavior, typePolicies, }: {
         schema: GraphQLSchema;
         mocks?: IMocks;
+        mockGenerationBehavior?: MockGenerationBehavior;
         typePolicies?: {
             [typeName: string]: TypePolicy;
         };
@@ -57,6 +52,8 @@ export declare class MockStore implements IMockStore {
  * Will create `MockStore` for the given `schema`.
  *
  * A `MockStore` will generate mock values for the given schema when queried.
+ * By default it'll generate random values, if this causes flakiness and you
+ * need a more deterministic behavior, use `mockGenerationBehavior` option.
  *
  * It will store generated mocks, so that, provided with same arguments
  * the returned values will be the same.
@@ -87,6 +84,29 @@ export declare function createMockStore(options: {
      * The mocks functions to use.
      */
     mocks?: IMocks;
+    /**
+     * Configures the default behavior for Scalar, Enum, Union, and Array types.
+     *
+     * When set to `random`, then every time a value is generated for a field with
+     * one of these types
+     * - For Unions and Enums one of the allowed values will be picked randomly
+     * - For Arrays an array of random length will be generated
+     * - For Int and Float scalars a random number will be generated
+     * - For Boolean scalars either `true` or `false` will be returned randomly
+     *
+     * When set to `deterministic`, then
+     * - For Unions and Enums the first allowed value is picked
+     * - For Arrays an array of two elements will be generated
+     * - For Int and Float scalars values 1 and 1.5 will be used respectively
+     * - For Boolean scalars we'll always return `true`
+     * - For String scalars we'll always return "Hello World"
+     *
+     * Regardless of the chosen behavior, for ID scalars a random UUID string
+     * will always be generated.
+     *
+     * @default "random"
+     */
+    mockGenerationBehavior?: MockGenerationBehavior;
     typePolicies?: {
         [typeName: string]: TypePolicy;
     };

package/typings/addMocksToSchema.d.cts

@@ -1,10 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { IResolvers } from '@graphql-tools/utils';
-import { IMocks, IMockStore, TypePolicy } from './types.cjs';
+import { IMocks, IMockStore, MockGenerationBehavior, TypePolicy } from './types.cjs';
 type IMockOptions<TResolvers = IResolvers> = {
     schema: GraphQLSchema;
     store?: IMockStore;
     mocks?: IMocks<TResolvers>;
+    mockGenerationBehavior?: MockGenerationBehavior;
     typePolicies?: {
         [typeName: string]: TypePolicy;
     };
@@ -74,5 +75,5 @@ type IMockOptions<TResolvers = IResolvers> = {
  *
  * `Query` and `Mutation` type will use `key` `'ROOT'`.
  */
-export declare function addMocksToSchema<TResolvers = IResolvers>({ schema, store: maybeStore, mocks, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers, }: IMockOptions<TResolvers>): GraphQLSchema;
+export declare function addMocksToSchema<TResolvers = IResolvers>({ schema, store: maybeStore, mocks, mockGenerationBehavior, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers, }: IMockOptions<TResolvers>): GraphQLSchema;
 export {};

package/typings/addMocksToSchema.d.ts

@@ -1,10 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { IResolvers } from '@graphql-tools/utils';
-import { IMocks, IMockStore, TypePolicy } from './types.js';
+import { IMocks, IMockStore, MockGenerationBehavior, TypePolicy } from './types.js';
 type IMockOptions<TResolvers = IResolvers> = {
     schema: GraphQLSchema;
     store?: IMockStore;
     mocks?: IMocks<TResolvers>;
+    mockGenerationBehavior?: MockGenerationBehavior;
     typePolicies?: {
         [typeName: string]: TypePolicy;
     };
@@ -74,5 +75,5 @@ type IMockOptions<TResolvers = IResolvers> = {
  *
  * `Query` and `Mutation` type will use `key` `'ROOT'`.
  */
-export declare function addMocksToSchema<TResolvers = IResolvers>({ schema, store: maybeStore, mocks, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers, }: IMockOptions<TResolvers>): GraphQLSchema;
+export declare function addMocksToSchema<TResolvers = IResolvers>({ schema, store: maybeStore, mocks, mockGenerationBehavior, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers, }: IMockOptions<TResolvers>): GraphQLSchema;
 export {};

package/typings/mockServer.d.cts

@@ -1,5 +1,5 @@
 import { TypeSource } from '@graphql-tools/utils';
-import { IMocks, IMockServer } from './types.cjs';
+import { IMocks, IMockServer, MockGenerationBehavior } from './types.cjs';
 /**
  * A convenience wrapper on top of `addMocksToSchema`. It adds your mock resolvers
  * to your schema and returns a client that will correctly execute your query with
@@ -11,5 +11,7 @@ import { IMocks, IMockServer } from './types.cjs';
  * @param preserveResolvers Set to `true` to prevent existing resolvers from being
  * overwritten to provide mock data. This can be used to mock some parts of the
  * server and not others.
+ * @param mockGenerationBehavior Set to `'deterministic'` if the default random
+ * mock generation behavior causes flakiness.
  */
-export declare function mockServer<TResolvers>(schema: TypeSource, mocks: IMocks<TResolvers>, preserveResolvers?: boolean): IMockServer;
+export declare function mockServer<TResolvers>(schema: TypeSource, mocks: IMocks<TResolvers>, preserveResolvers?: boolean, mockGenerationBehavior?: MockGenerationBehavior): IMockServer;

package/typings/mockServer.d.ts

@@ -1,5 +1,5 @@
 import { TypeSource } from '@graphql-tools/utils';
-import { IMocks, IMockServer } from './types.js';
+import { IMocks, IMockServer, MockGenerationBehavior } from './types.js';
 /**
  * A convenience wrapper on top of `addMocksToSchema`. It adds your mock resolvers
  * to your schema and returns a client that will correctly execute your query with
@@ -11,5 +11,7 @@ import { IMocks, IMockServer } from './types.js';
  * @param preserveResolvers Set to `true` to prevent existing resolvers from being
  * overwritten to provide mock data. This can be used to mock some parts of the
  * server and not others.
+ * @param mockGenerationBehavior Set to `'deterministic'` if the default random
+ * mock generation behavior causes flakiness.
  */
-export declare function mockServer<TResolvers>(schema: TypeSource, mocks: IMocks<TResolvers>, preserveResolvers?: boolean): IMockServer;
+export declare function mockServer<TResolvers>(schema: TypeSource, mocks: IMocks<TResolvers>, preserveResolvers?: boolean, mockGenerationBehavior?: MockGenerationBehavior): IMockServer;

package/typings/types.d.cts

@@ -14,6 +14,7 @@ export type IMocks<TResolvers = IResolvers> = {
 } & {
     [typeOrScalarName: string]: IScalarMock | ITypeMock;
 };
+export type MockGenerationBehavior = 'random' | 'deterministic';
 export type KeyTypeConstraints = string | number;
 export type TypePolicy = {
     /**

package/typings/types.d.ts

@@ -14,6 +14,7 @@ export type IMocks<TResolvers = IResolvers> = {
 } & {
     [typeOrScalarName: string]: IScalarMock | ITypeMock;
 };
+export type MockGenerationBehavior = 'random' | 'deterministic';
 export type KeyTypeConstraints = string | number;
 export type TypePolicy = {
     /**

package/typings/utils.d.cts

@@ -1,8 +1,8 @@
 import { GraphQLObjectType, GraphQLSchema } from 'graphql';
-import { KeyTypeConstraints, Ref } from './types.cjs';
+import { KeyTypeConstraints, MockGenerationBehavior, Ref } from './types.cjs';
 export declare function uuidv4(): string;
 export declare const randomListLength: () => number;
-export declare const takeRandom: <T>(arr: T[]) => T;
+export declare const takeOneOf: <T>(arr: T[], behavior: MockGenerationBehavior) => T;
 export declare function makeRef<KeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT): Ref<KeyT>;
 export declare function isObject(thing: any): boolean;
 export declare function copyOwnPropsIfNotPresent(target: Record<string, any>, source: Record<string, any>): void;

package/typings/utils.d.ts

@@ -1,8 +1,8 @@
 import { GraphQLObjectType, GraphQLSchema } from 'graphql';
-import { KeyTypeConstraints, Ref } from './types.js';
+import { KeyTypeConstraints, MockGenerationBehavior, Ref } from './types.js';
 export declare function uuidv4(): string;
 export declare const randomListLength: () => number;
-export declare const takeRandom: <T>(arr: T[]) => T;
+export declare const takeOneOf: <T>(arr: T[], behavior: MockGenerationBehavior) => T;
 export declare function makeRef<KeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT): Ref<KeyT>;
 export declare function isObject(thing: any): boolean;
 export declare function copyOwnPropsIfNotPresent(target: Record<string, any>, source: Record<string, any>): void;