@mnaoumov/typescript-lib 1.4.0 → 1.5.0

package/dist/lib/cjs/type-guards.cjs

@@ -119,6 +119,7 @@ function nullableTypeGuard(isValue) {
 }
 function objectTypeGuard(propertyTypeGuards, options) {
   const shouldRejectUnknownKeys = options?.shouldRejectUnknownKeys ?? false;
+  const exactOptionalKeys = options?.exactOptionalKeys;
   return (value) => {
     if (!isObject(value)) {
       return false;
@@ -126,8 +127,15 @@ function objectTypeGuard(propertyTypeGuards, options) {
     if (shouldRejectUnknownKeys && Object.keys(value).some((key) => !Object.hasOwn(propertyTypeGuards, key))) {
       return false;
     }
-    for (const key in propertyTypeGuards) {
-      if (!propertyTypeGuards[key](Reflect.get(value, key))) {
+    const typeGuards = propertyTypeGuards;
+    for (const [key, typeGuard] of Object.entries(typeGuards)) {
+      if (exactOptionalKeys && !Object.hasOwn(value, key)) {
+        if (Object.hasOwn(exactOptionalKeys, key)) {
+          continue;
+        }
+        return false;
+      }
+      if (!typeGuard(Reflect.get(value, key))) {
         return false;
       }
     }
@@ -168,4 +176,4 @@ function isReadonlyArray(value) {
   optionalTypeGuard,
   unionTypeGuard
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/type-guards.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for type guards, and combinators that build a {@link TypeGuard} out of others.\n *\n * The combinators here work on bare type guards. Their `api-contract` counterparts (`arrayGuard`, `optionalGuard`,\n * ...) work on an `ExpectedTypeGuard`, a type guard paired with the text an issue message reports, and their names\n * drop the `Type` this layer's names carry.\n */\n\nimport type { GenericFunction } from './function.ts';\n\nimport { noop } from './function.ts';\n\n/**\n * A type that represents a generic object.\n *\n * @typeParam T - The base type to intersect with.\n */\nexport type GenericObject<T = unknown> = Record<string | symbol, unknown> & T;\n\n/**\n * The type a {@link TypeGuard} narrows to. Distributes over a union of guards.\n *\n * @typeParam TTypeGuard - The type guard.\n */\nexport type GuardedType<TTypeGuard> = TTypeGuard extends (value: unknown) => value is infer T ? T : never;\n\n/**\n * A value {@link literalTypeGuard} can compare against.\n */\nexport type Literal = bigint | boolean | null | number | string | symbol | undefined;\n\n/**\n * Options for {@link objectTypeGuard}.\n */\nexport interface ObjectTypeGuardOptions {\n  /**\n   * Whether a value carrying an own enumerable string key that no property guard names is refused.\n   *\n   * @default `false`\n   */\n  readonly shouldRejectUnknownKeys?: boolean;\n}\n\n/**\n * One type guard per property of an object type, as {@link objectTypeGuard} takes them. Every key of `T` must be\n * listed. The guard of an optional property is typed to narrow to `undefined` as well, but a guard that refuses\n * `undefined` still compiles there, so widen it with {@link optionalTypeGuard}: an absent property reads as\n * `undefined`, and a guard refusing it refuses the object.\n *\n * @typeParam T - The object type.\n */\nexport type PropertyTypeGuards<T extends object> = {\n  readonly [TKey in keyof T]-?: TypeGuard<Partial<Pick<T, TKey>> extends Pick<T, TKey> ? T[TKey] | undefined : T[TKey]>;\n};\n\n/**\n * A function deciding whether a value is a `T`.\n *\n * @typeParam T - The type the guard narrows to.\n */\nexport type TypeGuard<T> = (value: unknown) => value is T;\n\ntype NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;\n\n/**\n * Builds a guard accepting an array whose every item the item guard accepts.\n *\n * @typeParam T - The type of an item.\n * @param isItem - The guard for one item.\n * @returns The guard.\n */\nexport function arrayTypeGuard<T>(isItem: TypeGuard<T>): TypeGuard<T[]> {\n  return (value): value is T[] => Array.isArray(value) && value.every((item) => isItem(item));\n}\n\n/**\n * Asserts that a condition is `true`. Throws if it is not.\n *\n * Use in place of `/* v8 ignore *\\/` for defensive guards that should\n * never trigger at runtime but would otherwise create uncovered branches.\n *\n * @param isTrue - The condition to assert.\n * @param errorOrMessage - The error or message to throw if the condition is `false`.\n */\nexport function assert(isTrue: boolean, errorOrMessage: Error | string): asserts isTrue {\n  if (!isTrue) {\n    throw typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  }\n}\n\n/**\n * Asserts that a value is a generic object, narrowing its type in place.\n *\n * @typeParam T - The type of the value.\n * @param _object - The value to assert.\n */\nexport function assertGenericObject<T>(_object: T): asserts _object is GenericObject<T> {\n  noop();\n}\n\n/**\n * Asserts at compile time that every case of a discriminated union has been\n * handled. Place at the `default` branch of a `switch` over a union or enum.\n *\n * If a new variant is added to the union without a matching `case`, the call\n * to {@link assertNever} fails to compile because `value` is no longer `never`.\n * If reached at runtime (e.g. because the value was bypassed via JSON or a\n * type assertion), it throws a descriptive `Error`.\n *\n * @example\n * ```ts\n * switch (mode) {\n *   case 'a': return doA();\n *   case 'b': return doB();\n *   default: assertNever(mode);\n * }\n * ```\n *\n * @param value - The exhaustively-handled value, narrowed to `never` by control flow.\n * @throws Always, if reached at runtime.\n */\nexport function assertNever(value: never): never {\n  throw new Error(`Unhandled value: ${String(value)}`);\n}\n\n/**\n * Asserts that a value is not `null` or `undefined`, narrowing its type in place.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @throws If the value is `null` or `undefined`.\n */\nexport function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T> {\n  if (value !== null && value !== undefined) {\n    return;\n  }\n\n  errorOrMessage ??= value === null ? 'Value is null' : 'Value is undefined';\n  const error = typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  throw error;\n}\n\n/**\n * Ensures that a value is a generic object, returning it with narrowed type.\n *\n * @typeParam T - The type of the value.\n * @param $object - The value to ensure.\n * @returns The value as a generic object.\n */\nexport function ensureGenericObject<T>($object: T): GenericObject<T> {\n  return $object as GenericObject<T>;\n}\n\n/**\n * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @returns The value with `null` and `undefined` excluded from its type.\n * @throws If the value is `null` or `undefined`.\n */\nexport function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T> {\n  assertNonNullable(value, errorOrMessage);\n  return value;\n}\n\n/**\n * Builds a guard accepting any function, narrowed to the signature `TFunction`. Only that the value is a function\n * is checked: a signature cannot be checked at runtime, so the guard trusts it.\n *\n * @typeParam TFunction - The signature the guard narrows to.\n * @returns The guard.\n */\nexport function functionTypeGuard<TFunction extends GenericFunction>(): TypeGuard<TFunction> {\n  return (value): value is TFunction => isFunction(value);\n}\n\n/**\n * Builds a guard accepting an instance of a class, or of a class derived from it.\n *\n * @typeParam T - The type of an instance.\n * @param constructor - The class.\n * @returns The guard.\n */\nexport function instanceOfTypeGuard<T>(constructor: abstract new (...arguments_: never[]) => T): TypeGuard<T> {\n  return (value): value is T => value instanceof constructor;\n}\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value - The value to check.\n * @returns Whether the value is a boolean.\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\n/**\n * Checks whether a value is a function.\n *\n * @param value - The value to check.\n * @returns Whether the value is a function.\n */\nexport function isFunction(value: unknown): value is GenericFunction {\n  return typeof value === 'function';\n}\n\n/**\n * Checks whether a value is `null`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `null`.\n */\nexport function isNull(value: unknown): value is null {\n  return value === null;\n}\n\n/**\n * Checks whether a value is a number.\n *\n * @param value - The value to check.\n * @returns Whether the value is a number.\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number';\n}\n\n/**\n * Checks whether a value is an object: not `null`, and not a primitive or a function.\n *\n * @param value - The value to check.\n * @returns Whether the value is an object.\n */\nexport function isObject(value: unknown): value is object {\n  return typeof value === 'object' && value !== null;\n}\n\n/**\n * Checks whether a value is a string.\n *\n * @param value - The value to check.\n * @returns Whether the value is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Checks whether a value is an array of strings.\n *\n * @param value - The value to check.\n * @returns Whether the value is an array whose every item is a string.\n */\nexport function isStringArray(value: unknown): value is string[] {\n  return Array.isArray(value) && value.every(isString);\n}\n\n/**\n * Checks whether a value is `undefined`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `undefined`.\n */\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined;\n}\n\n/**\n * Builds a guard accepting exactly the keys of a record. Typing the record over a union, as\n * `literalTypeGuard<Mode>({ A: true, B: true })`, makes a member later added to the union fail to compile until\n * it is listed.\n *\n * @typeParam T - The accepted strings.\n * @param literals - A record whose keys are the accepted strings.\n * @returns The guard.\n */\nexport function literalTypeGuard<T extends string>(literals: Readonly<Record<T, true>>): TypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values, compared as `Array.prototype.includes` compares them.\n *\n * @typeParam T - The accepted values.\n * @param literals - The accepted values.\n * @returns The guard.\n */\nexport function literalTypeGuard<T extends Literal>(literals: readonly T[]): TypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values.\n *\n * @param literals - The accepted values, as a list or as the keys of a record.\n * @returns The guard.\n */\nexport function literalTypeGuard(literals: Readonly<Record<string, true>> | readonly Literal[]): TypeGuard<Literal> {\n  if (isReadonlyArray(literals)) {\n    const literalList: readonly unknown[] = literals;\n    return (value): value is Literal => literalList.includes(value);\n  }\n\n  return (value): value is Literal => isString(value) && Object.hasOwn(literals, value);\n}\n\n/**\n * Widens a guard to also accept `null`.\n *\n * @typeParam T - The type the guard narrows to.\n * @param isValue - The guard to widen.\n * @returns A guard accepting what `isValue` accepts, or `null`.\n */\nexport function nullableTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<null | T> {\n  return unionTypeGuard(isNull, isValue);\n}\n\n/**\n * Builds a guard accepting an object whose every listed property its guard accepts. A property is read with\n * `Reflect.get`, so an inherited one counts and an absent one reads as `undefined`.\n *\n * @typeParam T - The object type.\n * @param propertyTypeGuards - One guard per property of `T`.\n * @param options - The options for the guard.\n * @returns The guard.\n */\nexport function objectTypeGuard<T extends object>(propertyTypeGuards: PropertyTypeGuards<T>, options?: ObjectTypeGuardOptions): TypeGuard<T> {\n  const shouldRejectUnknownKeys = options?.shouldRejectUnknownKeys ?? false;\n  return (value): value is T => {\n    if (!isObject(value)) {\n      return false;\n    }\n\n    if (shouldRejectUnknownKeys && Object.keys(value).some((key) => !Object.hasOwn(propertyTypeGuards, key))) {\n      return false;\n    }\n\n    for (const key in propertyTypeGuards) {\n      if (!propertyTypeGuards[key](Reflect.get(value, key))) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n\n/**\n * Widens a guard to also accept `undefined`, which is what an optional property or parameter reads as when it is\n * left out.\n *\n * @typeParam T - The type the guard narrows to.\n * @param isValue - The guard to widen.\n * @returns A guard accepting what `isValue` accepts, or `undefined`.\n */\nexport function optionalTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<T | undefined> {\n  return unionTypeGuard(isUndefined, isValue);\n}\n\n/**\n * Builds a guard accepting what any of the given guards accepts.\n *\n * @typeParam TTypeGuards - The guards.\n * @param typeGuards - The guards, tried in order.\n * @returns The guard.\n */\nexport function unionTypeGuard<const TTypeGuards extends readonly TypeGuard<unknown>[]>(\n  ...typeGuards: TTypeGuards\n): TypeGuard<GuardedType<TTypeGuards[number]>> {\n  return (value): value is GuardedType<TTypeGuards[number]> => typeGuards.some((typeGuard) => typeGuard(value));\n}\n\nfunction isReadonlyArray(value: unknown): value is readonly unknown[] {\n  return Array.isArray(value);\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/type-guards.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for type guards, and combinators that build a {@link TypeGuard} out of others.\n *\n * The combinators here work on bare type guards. Their `api-contract` counterparts (`arrayGuard`, `optionalGuard`,\n * ...) work on an `ExpectedTypeGuard`, a type guard paired with the text an issue message reports, and their names\n * drop the `Type` this layer's names carry.\n */\n\nimport type { GenericFunction } from './function.ts';\n\nimport { noop } from './function.ts';\n\n/**\n * A type that represents a generic object.\n *\n * @typeParam T - The base type to intersect with.\n */\nexport type GenericObject<T = unknown> = Record<string | symbol, unknown> & T;\n\n/**\n * The type a {@link TypeGuard} narrows to. Distributes over a union of guards.\n *\n * @typeParam TTypeGuard - The type guard.\n */\nexport type GuardedType<TTypeGuard> = TTypeGuard extends (value: unknown) => value is infer T ? T : never;\n\n/**\n * A value {@link literalTypeGuard} can compare against.\n */\nexport type Literal = bigint | boolean | null | number | string | symbol | undefined;\n\n/**\n * Options for {@link objectTypeGuard}.\n *\n * @typeParam T - The object type the guard narrows to.\n */\nexport interface ObjectTypeGuardOptions<T extends object = object> {\n  /**\n   * Switches the guard to EXACT optional properties, reading only the value's OWN keys. Listing it is the switch,\n   * so pass `{}` for a type with no optional key.\n   *\n   * Every optional key of `T` must be listed, so an optional property later added to `T` fails to compile until it\n   * is. A listed key may then be absent, and its guard is not run; present, even as `undefined`, it must pass its\n   * guard. Any other key must be present. An inherited key counts as absent.\n   *\n   * Without it, a property is read with `Reflect.get`, so an inherited one counts and an absent one reads as\n   * `undefined`, which the guard of an optional property must then accept.\n   */\n  readonly exactOptionalKeys?: Readonly<Record<OptionalKeys<T>, true>>;\n\n  /**\n   * Whether a value carrying an own enumerable string key that no property guard names is refused.\n   *\n   * @default `false`\n   */\n  readonly shouldRejectUnknownKeys?: boolean;\n}\n\n/**\n * The keys of an object type that are optional.\n *\n * @typeParam T - The object type.\n */\nexport type OptionalKeys<T extends object> = OptionalKeyMap<T>[keyof T];\n\n/**\n * One type guard per property of an object type, as {@link objectTypeGuard} takes them. Every key of `T` must be\n * listed. The guard of an optional property is typed to narrow to `undefined` as well, but a guard that refuses\n * `undefined` still compiles there, so widen it with {@link optionalTypeGuard}: an absent property reads as\n * `undefined`, and a guard refusing it refuses the object.\n *\n * @typeParam T - The object type.\n */\nexport type PropertyTypeGuards<T extends object> = {\n  readonly [TKey in keyof T]-?: TypeGuard<Partial<Pick<T, TKey>> extends Pick<T, TKey> ? T[TKey] | undefined : T[TKey]>;\n};\n\n/**\n * A function deciding whether a value is a `T`.\n *\n * @typeParam T - The type the guard narrows to.\n */\nexport type TypeGuard<T> = (value: unknown) => value is T;\n\ntype NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;\n\ntype OptionalKeyMap<T extends object> = {\n  [TKey in keyof T]-?: Partial<Pick<T, TKey>> extends Pick<T, TKey> ? TKey : never;\n};\n\n/**\n * Builds a guard accepting an array whose every item the item guard accepts.\n *\n * @typeParam T - The type of an item.\n * @param isItem - The guard for one item.\n * @returns The guard.\n */\nexport function arrayTypeGuard<T>(isItem: TypeGuard<T>): TypeGuard<T[]> {\n  return (value): value is T[] => Array.isArray(value) && value.every((item) => isItem(item));\n}\n\n/**\n * Asserts that a condition is `true`. Throws if it is not.\n *\n * Use in place of `/* v8 ignore *\\/` for defensive guards that should\n * never trigger at runtime but would otherwise create uncovered branches.\n *\n * @param isTrue - The condition to assert.\n * @param errorOrMessage - The error or message to throw if the condition is `false`.\n */\nexport function assert(isTrue: boolean, errorOrMessage: Error | string): asserts isTrue {\n  if (!isTrue) {\n    throw typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  }\n}\n\n/**\n * Asserts that a value is a generic object, narrowing its type in place.\n *\n * @typeParam T - The type of the value.\n * @param _object - The value to assert.\n */\nexport function assertGenericObject<T>(_object: T): asserts _object is GenericObject<T> {\n  noop();\n}\n\n/**\n * Asserts at compile time that every case of a discriminated union has been\n * handled. Place at the `default` branch of a `switch` over a union or enum.\n *\n * If a new variant is added to the union without a matching `case`, the call\n * to {@link assertNever} fails to compile because `value` is no longer `never`.\n * If reached at runtime (e.g. because the value was bypassed via JSON or a\n * type assertion), it throws a descriptive `Error`.\n *\n * @example\n * ```ts\n * switch (mode) {\n *   case 'a': return doA();\n *   case 'b': return doB();\n *   default: assertNever(mode);\n * }\n * ```\n *\n * @param value - The exhaustively-handled value, narrowed to `never` by control flow.\n * @throws Always, if reached at runtime.\n */\nexport function assertNever(value: never): never {\n  throw new Error(`Unhandled value: ${String(value)}`);\n}\n\n/**\n * Asserts that a value is not `null` or `undefined`, narrowing its type in place.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @throws If the value is `null` or `undefined`.\n */\nexport function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T> {\n  if (value !== null && value !== undefined) {\n    return;\n  }\n\n  errorOrMessage ??= value === null ? 'Value is null' : 'Value is undefined';\n  const error = typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  throw error;\n}\n\n/**\n * Ensures that a value is a generic object, returning it with narrowed type.\n *\n * @typeParam T - The type of the value.\n * @param $object - The value to ensure.\n * @returns The value as a generic object.\n */\nexport function ensureGenericObject<T>($object: T): GenericObject<T> {\n  return $object as GenericObject<T>;\n}\n\n/**\n * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @returns The value with `null` and `undefined` excluded from its type.\n * @throws If the value is `null` or `undefined`.\n */\nexport function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T> {\n  assertNonNullable(value, errorOrMessage);\n  return value;\n}\n\n/**\n * Builds a guard accepting any function, narrowed to the signature `TFunction`. Only that the value is a function\n * is checked: a signature cannot be checked at runtime, so the guard trusts it.\n *\n * @typeParam TFunction - The signature the guard narrows to.\n * @returns The guard.\n */\nexport function functionTypeGuard<TFunction extends GenericFunction>(): TypeGuard<TFunction> {\n  return (value): value is TFunction => isFunction(value);\n}\n\n/**\n * Builds a guard accepting an instance of a class, or of a class derived from it.\n *\n * @typeParam T - The type of an instance.\n * @param constructor - The class.\n * @returns The guard.\n */\nexport function instanceOfTypeGuard<T>(constructor: abstract new (...arguments_: never[]) => T): TypeGuard<T> {\n  return (value): value is T => value instanceof constructor;\n}\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value - The value to check.\n * @returns Whether the value is a boolean.\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\n/**\n * Checks whether a value is a function.\n *\n * @param value - The value to check.\n * @returns Whether the value is a function.\n */\nexport function isFunction(value: unknown): value is GenericFunction {\n  return typeof value === 'function';\n}\n\n/**\n * Checks whether a value is `null`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `null`.\n */\nexport function isNull(value: unknown): value is null {\n  return value === null;\n}\n\n/**\n * Checks whether a value is a number.\n *\n * @param value - The value to check.\n * @returns Whether the value is a number.\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number';\n}\n\n/**\n * Checks whether a value is an object: not `null`, and not a primitive or a function.\n *\n * @param value - The value to check.\n * @returns Whether the value is an object.\n */\nexport function isObject(value: unknown): value is object {\n  return typeof value === 'object' && value !== null;\n}\n\n/**\n * Checks whether a value is a string.\n *\n * @param value - The value to check.\n * @returns Whether the value is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Checks whether a value is an array of strings.\n *\n * @param value - The value to check.\n * @returns Whether the value is an array whose every item is a string.\n */\nexport function isStringArray(value: unknown): value is string[] {\n  return Array.isArray(value) && value.every(isString);\n}\n\n/**\n * Checks whether a value is `undefined`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `undefined`.\n */\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined;\n}\n\n/**\n * Builds a guard accepting exactly the keys of a record. Typing the record over a union, as\n * `literalTypeGuard<Mode>({ A: true, B: true })`, makes a member later added to the union fail to compile until\n * it is listed.\n *\n * @typeParam T - The accepted strings.\n * @param literals - A record whose keys are the accepted strings.\n * @returns The guard.\n */\nexport function literalTypeGuard<T extends string>(literals: Readonly<Record<T, true>>): TypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values, compared as `Array.prototype.includes` compares them.\n *\n * @typeParam T - The accepted values.\n * @param literals - The accepted values.\n * @returns The guard.\n */\nexport function literalTypeGuard<T extends Literal>(literals: readonly T[]): TypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values.\n *\n * @param literals - The accepted values, as a list or as the keys of a record.\n * @returns The guard.\n */\nexport function literalTypeGuard(literals: Readonly<Record<string, true>> | readonly Literal[]): TypeGuard<Literal> {\n  if (isReadonlyArray(literals)) {\n    const literalList: readonly unknown[] = literals;\n    return (value): value is Literal => literalList.includes(value);\n  }\n\n  return (value): value is Literal => isString(value) && Object.hasOwn(literals, value);\n}\n\n/**\n * Widens a guard to also accept `null`.\n *\n * @typeParam T - The type the guard narrows to.\n * @param isValue - The guard to widen.\n * @returns A guard accepting what `isValue` accepts, or `null`.\n */\nexport function nullableTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<null | T> {\n  return unionTypeGuard(isNull, isValue);\n}\n\n/**\n * Builds a guard accepting an object whose every listed property its guard accepts. A property is read with\n * `Reflect.get`, so an inherited one counts and an absent one reads as `undefined`, unless\n * {@link ObjectTypeGuardOptions.exactOptionalKeys} switches the guard to own keys and exact optional properties.\n *\n * @typeParam T - The object type.\n * @param propertyTypeGuards - One guard per property of `T`.\n * @param options - The options for the guard.\n * @returns The guard.\n */\nexport function objectTypeGuard<T extends object>(propertyTypeGuards: PropertyTypeGuards<T>, options?: ObjectTypeGuardOptions<T>): TypeGuard<T> {\n  const shouldRejectUnknownKeys = options?.shouldRejectUnknownKeys ?? false;\n  const exactOptionalKeys = options?.exactOptionalKeys;\n  return (value): value is T => {\n    if (!isObject(value)) {\n      return false;\n    }\n\n    if (shouldRejectUnknownKeys && Object.keys(value).some((key) => !Object.hasOwn(propertyTypeGuards, key))) {\n      return false;\n    }\n\n    const typeGuards: Readonly<Record<string, TypeGuard<unknown>>> = propertyTypeGuards;\n    for (const [key, typeGuard] of Object.entries(typeGuards)) {\n      if (exactOptionalKeys && !Object.hasOwn(value, key)) {\n        if (Object.hasOwn(exactOptionalKeys, key)) {\n          continue;\n        }\n\n        return false;\n      }\n\n      if (!typeGuard(Reflect.get(value, key))) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n\n/**\n * Widens a guard to also accept `undefined`, which is what an optional property or parameter reads as when it is\n * left out.\n *\n * @typeParam T - The type the guard narrows to.\n * @param isValue - The guard to widen.\n * @returns A guard accepting what `isValue` accepts, or `undefined`.\n */\nexport function optionalTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<T | undefined> {\n  return unionTypeGuard(isUndefined, isValue);\n}\n\n/**\n * Builds a guard accepting what any of the given guards accepts.\n *\n * @typeParam TTypeGuards - The guards.\n * @param typeGuards - The guards, tried in order.\n * @returns The guard.\n */\nexport function unionTypeGuard<const TTypeGuards extends readonly TypeGuard<unknown>[]>(\n  ...typeGuards: TTypeGuards\n): TypeGuard<GuardedType<TTypeGuards[number]>> {\n  return (value): value is GuardedType<TTypeGuards[number]> => typeGuards.some((typeGuard) => typeGuard(value));\n}\n\nfunction isReadonlyArray(value: unknown): value is readonly unknown[] {\n  return Array.isArray(value);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/type-guards.d.cts

@@ -27,8 +27,22 @@ export type GuardedType<TTypeGuard> = TTypeGuard extends (value: unknown) => val
 export type Literal = bigint | boolean | null | number | string | symbol | undefined;
 /**
  * Options for {@link objectTypeGuard}.
+ *
+ * @typeParam T - The object type the guard narrows to.
  */
-export interface ObjectTypeGuardOptions {
+export interface ObjectTypeGuardOptions<T extends object = object> {
+    /**
+     * Switches the guard to EXACT optional properties, reading only the value's OWN keys. Listing it is the switch,
+     * so pass `{}` for a type with no optional key.
+     *
+     * Every optional key of `T` must be listed, so an optional property later added to `T` fails to compile until it
+     * is. A listed key may then be absent, and its guard is not run; present, even as `undefined`, it must pass its
+     * guard. Any other key must be present. An inherited key counts as absent.
+     *
+     * Without it, a property is read with `Reflect.get`, so an inherited one counts and an absent one reads as
+     * `undefined`, which the guard of an optional property must then accept.
+     */
+    readonly exactOptionalKeys?: Readonly<Record<OptionalKeys<T>, true>>;
     /**
      * Whether a value carrying an own enumerable string key that no property guard names is refused.
      *
@@ -36,6 +50,12 @@ export interface ObjectTypeGuardOptions {
      */
     readonly shouldRejectUnknownKeys?: boolean;
 }
+/**
+ * The keys of an object type that are optional.
+ *
+ * @typeParam T - The object type.
+ */
+export type OptionalKeys<T extends object> = OptionalKeyMap<T>[keyof T];
 /**
  * One type guard per property of an object type, as {@link objectTypeGuard} takes them. Every key of `T` must be
  * listed. The guard of an optional property is typed to narrow to `undefined` as well, but a guard that refuses
@@ -54,6 +74,9 @@ export type PropertyTypeGuards<T extends object> = {
  */
 export type TypeGuard<T> = (value: unknown) => value is T;
 type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;
+type OptionalKeyMap<T extends object> = {
+    [TKey in keyof T]-?: Partial<Pick<T, TKey>> extends Pick<T, TKey> ? TKey : never;
+};
 /**
  * Builds a guard accepting an array whose every item the item guard accepts.
  *
@@ -232,14 +255,15 @@ export declare function literalTypeGuard<T extends Literal>(literals: readonly T
 export declare function nullableTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<null | T>;
 /**
  * Builds a guard accepting an object whose every listed property its guard accepts. A property is read with
- * `Reflect.get`, so an inherited one counts and an absent one reads as `undefined`.
+ * `Reflect.get`, so an inherited one counts and an absent one reads as `undefined`, unless
+ * {@link ObjectTypeGuardOptions.exactOptionalKeys} switches the guard to own keys and exact optional properties.
  *
  * @typeParam T - The object type.
  * @param propertyTypeGuards - One guard per property of `T`.
  * @param options - The options for the guard.
  * @returns The guard.
  */
-export declare function objectTypeGuard<T extends object>(propertyTypeGuards: PropertyTypeGuards<T>, options?: ObjectTypeGuardOptions): TypeGuard<T>;
+export declare function objectTypeGuard<T extends object>(propertyTypeGuards: PropertyTypeGuards<T>, options?: ObjectTypeGuardOptions<T>): TypeGuard<T>;
 /**
  * Widens a guard to also accept `undefined`, which is what an optional property or parameter reads as when it is
  * left out.

package/dist/lib/esm/api-contract-verifier.d.mts

@@ -0,0 +1,81 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Checks an {@link ApiContract} against sample payloads, for a contract's own test: every method has both schemas,
+ * every schema reports the expected vendor, and each schema accepts every valid payload and refuses every invalid one.
+ *
+ * It returns what it found rather than asserting, so it runs under any test framework:
+ *
+ * ```ts
+ * expect(await verifyApiContract(MY_API_CONTRACT, { cases, vendor: 'my-plugin' })).toEqual([]);
+ * ```
+ *
+ * It lives apart from `api-contract.ts` because a contract a consumer copies imports that module into its plugin,
+ * and nothing here is needed at runtime.
+ */
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { ApiContract } from './api-contract.mjs';
+/**
+ * The sample payloads of one method, for each half of its contract.
+ */
+export interface ApiMethodCases {
+    /**
+     * Sample argument lists.
+     */
+    readonly input: PayloadCases;
+    /**
+     * Sample return values.
+     */
+    readonly output: PayloadCases;
+}
+/**
+ * Sample payloads for one schema.
+ */
+export interface PayloadCases {
+    /**
+     * Payloads the schema must refuse.
+     */
+    readonly invalid: readonly unknown[];
+    /**
+     * Payloads the schema must accept.
+     */
+    readonly valid: readonly unknown[];
+}
+/**
+ * Options for {@link verifyApiContract}.
+ *
+ * @typeParam TContract - The contract.
+ */
+export interface VerifyApiContractOptions<TContract extends ApiContract> {
+    /**
+     * The sample payloads, one entry per method of the contract.
+     */
+    readonly cases: Readonly<Record<keyof TContract & string, ApiMethodCases>>;
+    /**
+     * The Standard Schema `vendor` every schema must report.
+     */
+    readonly vendor: string;
+}
+/**
+ * Runs a Standard Schema that must be synchronous. A schema guarding a call it cannot delay, as a contract's schemas
+ * do, has to answer before that call returns.
+ *
+ * @typeParam TOutput - The type the schema produces.
+ * @param schema - The schema.
+ * @param value - The value to validate.
+ * @returns The schema's result.
+ * @throws If the schema answers with a promise.
+ */
+export declare function validateSync<TOutput>(schema: StandardSchemaV1<unknown, TOutput>, value: unknown): StandardSchemaV1.Result<TOutput>;
+/**
+ * Checks a contract against sample payloads: the contract has exactly the methods the cases name, each with both
+ * schemas, every schema reports the given vendor and Standard Schema version 1, and each schema accepts every valid
+ * payload and refuses every invalid one.
+ *
+ * @typeParam TContract - The contract.
+ * @param contract - The contract.
+ * @param options - The sample payloads and the expected vendor.
+ * @returns One message per violation, empty when the contract passes.
+ */
+export declare function verifyApiContract<TContract extends ApiContract>(contract: TContract, options: VerifyApiContractOptions<TContract>): Promise<string[]>;

package/dist/lib/esm/api-contract-verifier.mjs

@@ -0,0 +1,63 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+function validateSync(schema, value) {
+  const result = schema["~standard"].validate(value);
+  if (result instanceof Promise) {
+    throw new TypeError("Expected a synchronous schema, got one that answers with a promise.");
+  }
+  return result;
+}
+async function verifyApiContract(contract, options) {
+  const violations = [];
+  const looseContract = contract;
+  const cases = options.cases;
+  for (const methodName of Object.keys(looseContract)) {
+    if (!Object.hasOwn(cases, methodName)) {
+      violations.push(`${methodName}: the contract has the method, but no cases are given for it.`);
+    }
+  }
+  for (const [methodName, methodCases] of Object.entries(cases)) {
+    const methodContract = looseContract[methodName];
+    if (methodContract === void 0) {
+      violations.push(`${methodName}: cases are given, but the contract has no such method.`);
+      continue;
+    }
+    for (const half of ["input", "output"]) {
+      const schema = methodContract[half];
+      if (schema === void 0) {
+        violations.push(`${methodName} ${half}: the contract has no schema.`);
+        continue;
+      }
+      const { vendor } = schema["~standard"];
+      const version = schema["~standard"].version;
+      if (vendor !== options.vendor || version !== 1) {
+        violations.push(`${methodName} ${half}: the schema reports vendor '${vendor}' and version ${String(version)}, expected '${options.vendor}' and 1.`);
+      }
+      const { invalid, valid } = methodCases[half];
+      for (const [index, value] of valid.entries()) {
+        const result = await schema["~standard"].validate(value);
+        if (result.issues !== void 0) {
+          violations.push(`${methodName} ${half}: valid case ${String(index)} was refused: ${formatIssues(result.issues)}`);
+        }
+      }
+      for (const [index, value] of invalid.entries()) {
+        const result = await schema["~standard"].validate(value);
+        if (result.issues === void 0 || result.issues.length === 0) {
+          violations.push(`${methodName} ${half}: invalid case ${String(index)} was accepted.`);
+        }
+      }
+    }
+  }
+  return violations;
+}
+function formatIssues(issues) {
+  return issues.map((issue) => issue.message).join(" ");
+}
+export {
+  validateSync,
+  verifyApiContract
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/api-contract-verifier.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Checks an {@link ApiContract} against sample payloads, for a contract's own test: every method has both schemas,\n * every schema reports the expected vendor, and each schema accepts every valid payload and refuses every invalid one.\n *\n * It returns what it found rather than asserting, so it runs under any test framework:\n *\n * ```ts\n * expect(await verifyApiContract(MY_API_CONTRACT, { cases, vendor: 'my-plugin' })).toEqual([]);\n * ```\n *\n * It lives apart from `api-contract.ts` because a contract a consumer copies imports that module into its plugin,\n * and nothing here is needed at runtime.\n */\n\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\n\nimport type { ApiContract } from './api-contract.ts';\n\n/**\n * The sample payloads of one method, for each half of its contract.\n */\nexport interface ApiMethodCases {\n  /**\n   * Sample argument lists.\n   */\n  readonly input: PayloadCases;\n\n  /**\n   * Sample return values.\n   */\n  readonly output: PayloadCases;\n}\n\n/**\n * Sample payloads for one schema.\n */\nexport interface PayloadCases {\n  /**\n   * Payloads the schema must refuse.\n   */\n  readonly invalid: readonly unknown[];\n\n  /**\n   * Payloads the schema must accept.\n   */\n  readonly valid: readonly unknown[];\n}\n\n/**\n * Options for {@link verifyApiContract}.\n *\n * @typeParam TContract - The contract.\n */\nexport interface VerifyApiContractOptions<TContract extends ApiContract> {\n  /**\n   * The sample payloads, one entry per method of the contract.\n   */\n  readonly cases: Readonly<Record<keyof TContract & string, ApiMethodCases>>;\n\n  /**\n   * The Standard Schema `vendor` every schema must report.\n   */\n  readonly vendor: string;\n}\n\n/**\n * Runs a Standard Schema that must be synchronous. A schema guarding a call it cannot delay, as a contract's schemas\n * do, has to answer before that call returns.\n *\n * @typeParam TOutput - The type the schema produces.\n * @param schema - The schema.\n * @param value - The value to validate.\n * @returns The schema's result.\n * @throws If the schema answers with a promise.\n */\nexport function validateSync<TOutput>(schema: StandardSchemaV1<unknown, TOutput>, value: unknown): StandardSchemaV1.Result<TOutput> {\n  const result = schema['~standard'].validate(value);\n  if (result instanceof Promise) {\n    throw new TypeError('Expected a synchronous schema, got one that answers with a promise.');\n  }\n\n  return result;\n}\n\n/**\n * Checks a contract against sample payloads: the contract has exactly the methods the cases name, each with both\n * schemas, every schema reports the given vendor and Standard Schema version 1, and each schema accepts every valid\n * payload and refuses every invalid one.\n *\n * @typeParam TContract - The contract.\n * @param contract - The contract.\n * @param options - The sample payloads and the expected vendor.\n * @returns One message per violation, empty when the contract passes.\n */\nexport async function verifyApiContract<TContract extends ApiContract>(contract: TContract, options: VerifyApiContractOptions<TContract>): Promise<string[]> {\n  const violations: string[] = [];\n  const looseContract: ApiContract = contract;\n  const cases: Readonly<Record<string, ApiMethodCases>> = options.cases;\n\n  for (const methodName of Object.keys(looseContract)) {\n    if (!Object.hasOwn(cases, methodName)) {\n      violations.push(`${methodName}: the contract has the method, but no cases are given for it.`);\n    }\n  }\n\n  for (const [methodName, methodCases] of Object.entries(cases)) {\n    const methodContract = looseContract[methodName];\n    if (methodContract === undefined) {\n      violations.push(`${methodName}: cases are given, but the contract has no such method.`);\n      continue;\n    }\n\n    for (const half of ['input', 'output'] as const) {\n      const schema = methodContract[half];\n      if (schema === undefined) {\n        violations.push(`${methodName} ${half}: the contract has no schema.`);\n        continue;\n      }\n\n      // Read as a number: the type says 1, but a schema from another library may speak a later version.\n      const { vendor } = schema['~standard'];\n      const version: number = schema['~standard'].version;\n      if (vendor !== options.vendor || version !== 1) {\n        violations.push(`${methodName} ${half}: the schema reports vendor '${vendor}' and version ${String(version)}, expected '${options.vendor}' and 1.`);\n      }\n\n      const { invalid, valid } = methodCases[half];\n      for (const [index, value] of valid.entries()) {\n        const result = await schema['~standard'].validate(value);\n        if (result.issues !== undefined) {\n          violations.push(`${methodName} ${half}: valid case ${String(index)} was refused: ${formatIssues(result.issues)}`);\n        }\n      }\n\n      for (const [index, value] of invalid.entries()) {\n        const result = await schema['~standard'].validate(value);\n        if (result.issues === undefined || result.issues.length === 0) {\n          violations.push(`${methodName} ${half}: invalid case ${String(index)} was accepted.`);\n        }\n      }\n    }\n  }\n\n  return violations;\n}\n\nfunction formatIssues(issues: readonly StandardSchemaV1.Issue[]): string {\n  return issues.map((issue) => issue.message).join(' ');\n}\n"],
  "mappings": ";;;;;AA6EO,SAAS,aAAsB,QAA4C,OAAkD;AAClI,QAAM,SAAS,OAAO,WAAW,EAAE,SAAS,KAAK;AACjD,MAAI,kBAAkB,SAAS;AAC7B,UAAM,IAAI,UAAU,qEAAqE;AAAA,EAC3F;AAEA,SAAO;AACT;AAYA,eAAsB,kBAAiD,UAAqB,SAAiE;AAC3J,QAAM,aAAuB,CAAC;AAC9B,QAAM,gBAA6B;AACnC,QAAM,QAAkD,QAAQ;AAEhE,aAAW,cAAc,OAAO,KAAK,aAAa,GAAG;AACnD,QAAI,CAAC,OAAO,OAAO,OAAO,UAAU,GAAG;AACrC,iBAAW,KAAK,GAAG,UAAU,+DAA+D;AAAA,IAC9F;AAAA,EACF;AAEA,aAAW,CAAC,YAAY,WAAW,KAAK,OAAO,QAAQ,KAAK,GAAG;AAC7D,UAAM,iBAAiB,cAAc,UAAU;AAC/C,QAAI,mBAAmB,QAAW;AAChC,iBAAW,KAAK,GAAG,UAAU,yDAAyD;AACtF;AAAA,IACF;AAEA,eAAW,QAAQ,CAAC,SAAS,QAAQ,GAAY;AAC/C,YAAM,SAAS,eAAe,IAAI;AAClC,UAAI,WAAW,QAAW;AACxB,mBAAW,KAAK,GAAG,UAAU,IAAI,IAAI,+BAA+B;AACpE;AAAA,MACF;AAGA,YAAM,EAAE,OAAO,IAAI,OAAO,WAAW;AACrC,YAAM,UAAkB,OAAO,WAAW,EAAE;AAC5C,UAAI,WAAW,QAAQ,UAAU,YAAY,GAAG;AAC9C,mBAAW,KAAK,GAAG,UAAU,IAAI,IAAI,gCAAgC,MAAM,iBAAiB,OAAO,OAAO,CAAC,eAAe,QAAQ,MAAM,UAAU;AAAA,MACpJ;AAEA,YAAM,EAAE,SAAS,MAAM,IAAI,YAAY,IAAI;AAC3C,iBAAW,CAAC,OAAO,KAAK,KAAK,MAAM,QAAQ,GAAG;AAC5C,cAAM,SAAS,MAAM,OAAO,WAAW,EAAE,SAAS,KAAK;AACvD,YAAI,OAAO,WAAW,QAAW;AAC/B,qBAAW,KAAK,GAAG,UAAU,IAAI,IAAI,gBAAgB,OAAO,KAAK,CAAC,iBAAiB,aAAa,OAAO,MAAM,CAAC,EAAE;AAAA,QAClH;AAAA,MACF;AAEA,iBAAW,CAAC,OAAO,KAAK,KAAK,QAAQ,QAAQ,GAAG;AAC9C,cAAM,SAAS,MAAM,OAAO,WAAW,EAAE,SAAS,KAAK;AACvD,YAAI,OAAO,WAAW,UAAa,OAAO,OAAO,WAAW,GAAG;AAC7D,qBAAW,KAAK,GAAG,UAAU,IAAI,IAAI,kBAAkB,OAAO,KAAK,CAAC,gBAAgB;AAAA,QACtF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,aAAa,QAAmD;AACvE,SAAO,OAAO,IAAI,CAAC,UAAU,MAAM,OAAO,EAAE,KAAK,GAAG;AACtD;",
  "names": []
}


package/dist/lib/esm/api-contract.d.mts

@@ -14,7 +14,7 @@
  * Running the schemas is left to whoever owns the call path, since that is where an issue can be reported.
  */
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { GuardedType, Literal, TypeGuard } from './type-guards.mjs';
+import type { GuardedType, Literal, ObjectTypeGuardOptions, TypeGuard } from './type-guards.mjs';
 /**
  * The contract an API declares: every key is a method the API promises to expose, and its value optionally
  * carries the payload schemas for that method.
@@ -126,6 +126,52 @@ export interface ExpectedTypeGuard<T> {
      */
     readonly typeGuard: (value: unknown) => value is T;
 }
+/**
+ * Options for {@link objectGuard}.
+ *
+ * @typeParam T - The object type the guard narrows to.
+ */
+export interface ObjectGuardOptions<T extends object> extends ObjectTypeGuardOptions<T> {
+    /**
+     * What the object is, put before its properties in `expected`, e.g. `'the options of the link'`.
+     */
+    readonly description?: string;
+}
+/**
+ * One guard per option of an all-optional object type, as {@link optionsGuard} takes them: each describes a
+ * PRESENT option, so it does not accept `undefined`. A required property of `T` takes `never`, so a type that is
+ * not all-optional does not compile.
+ *
+ * @typeParam T - The object type.
+ */
+export type OptionGuards<T extends object> = {
+    readonly [TKey in keyof T]-?: Partial<Pick<T, TKey>> extends Pick<T, TKey> ? ExpectedTypeGuard<Exclude<T[TKey], undefined>> : never;
+};
+/**
+ * Options for {@link optionsGuard}.
+ */
+export interface OptionsGuardOptions {
+    /**
+     * What the options are, put before them in `expected`, e.g. `'select options'`.
+     */
+    readonly description?: string;
+    /**
+     * Whether a value carrying an own enumerable string key that no option guard names is refused. Letting it through,
+     * the default, lets a consumer compiled against a later version of the options pass one this version does not know.
+     *
+     * @default `false`
+     */
+    readonly shouldRejectUnknownKeys?: boolean;
+}
+/**
+ * One guard per property of an object type, as {@link objectGuard} takes them, typed as {@link PropertyTypeGuards}
+ * types the bare guards.
+ *
+ * @typeParam T - The object type.
+ */
+export type PropertyGuards<T extends object> = {
+    readonly [TKey in keyof T]-?: ExpectedTypeGuard<Partial<Pick<T, TKey>> extends Pick<T, TKey> ? T[TKey] | undefined : T[TKey]>;
+};
 /**
  * The {@link ApiContract} of a named API: one entry per function member, each typed against that member. Both
  * schemas are REQUIRED here, so a typed contract is a full description of every signature and a `{}` entry does
@@ -251,6 +297,19 @@ export declare function literalGuard<T extends Literal>(literals: readonly T[]):
  * @returns A guard accepting what `guard` accepts, or `null`.
  */
 export declare function nullableGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedTypeGuard<null | T>;
+/**
+ * Builds a guard accepting an object whose every listed property its guard accepts, as {@link objectTypeGuard} does,
+ * expecting the properties and what each expects: `{ alias?: a string; path: a string }`, after the
+ * {@link ObjectGuardOptions.description} when one is given. A key is marked optional when it is listed in
+ * {@link ObjectTypeGuardOptions.exactOptionalKeys}; without that list, an optional property's guard says
+ * `or undefined` itself.
+ *
+ * @typeParam T - The object type.
+ * @param propertyGuards - One guard per property of `T`.
+ * @param options - The options for the guard.
+ * @returns The guard.
+ */
+export declare function objectGuard<T extends object>(propertyGuards: PropertyGuards<T>, options?: ObjectGuardOptions<T>): ExpectedTypeGuard<T>;
 /**
  * Widens a guard to also accept `undefined`, which is what an optional parameter receives when it is left out.
  *
@@ -259,6 +318,18 @@ export declare function nullableGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedT
  * @returns A guard accepting what `guard` accepts, or `undefined`.
  */
 export declare function optionalGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedTypeGuard<T | undefined>;
+/**
+ * Builds a guard accepting an options bag: an object whose every option may be absent, or `undefined`, and must
+ * otherwise pass its guard. A key no guard names is let through unless
+ * {@link OptionsGuardOptions.shouldRejectUnknownKeys} is set. It expects the options and what each expects:
+ * `{ prefix?: a string; isHidden?: a boolean }`, after the {@link OptionsGuardOptions.description} when one is given.
+ *
+ * @typeParam T - The options type, every property of which is optional.
+ * @param optionGuards - One guard per option of `T`, for a present value.
+ * @param options - The options for the guard.
+ * @returns The guard.
+ */
+export declare function optionsGuard<T extends object>(optionGuards: OptionGuards<T>, options?: OptionsGuardOptions): ExpectedTypeGuard<T>;
 /**
  * Builds a guard accepting what any of the given guards accepts, expecting their `expected` texts joined by `or`.
  *