bupkis 0.18.1 → 0.18.2

package/dist/assertion/impl/sync-esoteric.cjs

@@ -1,214 +0,0 @@
-"use strict";
-/**
- * "Esoteric" object assertions that don't fit into more common categories.
- *
- * These are probably less commonly used, but still useful in certain scenarios.
- *
- * @module
- * @groupDescription Esoteric Assertions
- * Individual assertions are documented where they are exported.
- *
- * @showGroups
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extensibleAssertion = exports.frozenAssertion = exports.sealedAssertion = exports.enumerablePropertyAssertion2 = exports.enumerablePropertyAssertion = exports.nullPrototypeAssertion = void 0;
-const zod_1 = require("zod");
-const guards_js_1 = require("../../guards.cjs");
-const schema_js_1 = require("../../schema.cjs");
-const create_js_1 = require("../create.cjs");
-const { getOwnPropertyDescriptor, isExtensible, isFrozen, isSealed } = Object;
-/**
- * Asserts that an object has a null prototype (i.e.,
- * `Object.getPrototypeOf(obj) === null`).
- *
- * This is useful for checking if an object was created with
- * `Object.create(null)` or similar patterns that create truly "dictionary-like"
- * objects without any inherited properties.
- *
- * @example
- *
- * ```typescript
- * const obj = Object.create(null);
- * expect(obj, 'to have a null prototype'); // ✓ passes
- *
- * const regular = {};
- * expect(regular, 'to have a null prototype'); // ✗ fails - has Object.prototype
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor object-to-have-a-null-prototype
- * @bupkisAssertionCategory object
- */
-exports.nullPrototypeAssertion = (0, create_js_1.createAssertion)([['to have a null prototype', 'to be a dictionary']], schema_js_1.DictionarySchema);
-/**
- * Asserts that a given property key is an enumerable property of the target
- * object.
- *
- * This checks the `enumerable` descriptor property using
- * `Object.getOwnPropertyDescriptor()`. Only own properties (not inherited ones)
- * are considered, and the property must be enumerable (i.e., would appear in
- * `for...in` loops and `Object.keys()` results).
- *
- * @example
- *
- * ```typescript
- * const obj = { visible: 'value' };
- * Object.defineProperty(obj, 'hidden', {
- *   value: 'secret',
- *   enumerable: false,
- * });
- *
- * expect('visible', 'to be an enumerable property of', obj); // ✓ passes
- * expect('hidden', 'to be an enumerable property of', obj); // ✗ fails - not enumerable
- * expect('toString', 'to be an enumerable property of', obj); // ✗ fails - inherited property
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor string-number-symbol-to-be-an-enumerable-property-of-non-null
- * @bupkisAssertionCategory object
- */
-exports.enumerablePropertyAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.PropertyKeySchema,
-    'to be an enumerable property of',
-    zod_1.z.unknown().nonoptional(),
-], (subject, obj) => {
-    if (!getOwnPropertyDescriptor(obj, subject)?.enumerable) {
-        return {
-            actual: false,
-            expected: true,
-            message: `Expected property ${String(subject)} to be enumerable`,
-        };
-    }
-});
-/**
- * Asserts that an object has a specified property that is enumerable.
- *
- * This is an alternative form of {@link enumerablePropertyAssertion} with the
- * object and property key parameters in reverse order. It checks that the given
- * property exists on the object and has its `enumerable` descriptor set to
- * `true` using `Object.getOwnPropertyDescriptor()`. Only own properties (not
- * inherited ones) are considered.
- *
- * @example
- *
- * ```typescript
- * const obj = { visible: 'value' };
- * Object.defineProperty(obj, 'hidden', {
- *   value: 'secret',
- *   enumerable: false,
- * });
- *
- * expect(obj, 'to have enumerable property', 'visible'); // ✓ passes
- * expect(obj, 'to have enumerable property', 'hidden'); // ✗ fails - not enumerable
- * expect(obj, 'to have enumerable property', 'nonexistent'); // ✗ fails - property doesn't exist
- * ```
- *
- * @param subject - The object to check for the enumerable property
- * @param key - The property key to test for enumerability
- * @group Esoteric Assertions
- * @see {@link enumerablePropertyAssertion} - Alternative parameter order
- */
-exports.enumerablePropertyAssertion2 = (0, create_js_1.createAssertion)([zod_1.z.unknown().nonoptional(), 'to have enumerable property', schema_js_1.PropertyKeySchema], (_subject, key) => zod_1.z.custom((value) => (0, guards_js_1.isNonNullObject)(value) &&
-    key in value &&
-    !!getOwnPropertyDescriptor(value, key)?.enumerable, {
-    error: `Expected property "${String(key)}" to be enumerable`,
-}));
-/**
- * Asserts that an object is sealed using `Object.isSealed()`.
- *
- * A sealed object cannot have new properties added to it, and all existing
- * properties are marked as non-configurable. However, writable properties can
- * still be modified. This is less restrictive than being frozen but more
- * restrictive than being non-extensible.
- *
- * @example
- *
- * ```typescript
- * const obj = { prop: 'value' };
- * Object.seal(obj);
- *
- * expect(obj, 'to be sealed'); // ✓ passes
- *
- * obj.prop = 'new value'; // This still works
- * obj.newProp = 'fail'; // This will fail (in strict mode)
- *
- * const regular = {};
- * expect(regular, 'to be sealed'); // ✗ fails - not sealed
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor unknown-to-be-sealed
- * @bupkisAssertionCategory object
- */
-exports.sealedAssertion = (0, create_js_1.createAssertion)(['to be sealed'], schema_js_1.UnknownSchema.refine((obj) => isSealed(obj)));
-/**
- * Asserts that an object is frozen using `Object.isFrozen()`.
- *
- * A frozen object is completely immutable - no properties can be added,
- * removed, or modified, and no property descriptors can be changed. This is the
- * most restrictive object state. Frozen objects are automatically sealed and
- * non-extensible.
- *
- * @example
- *
- * ```typescript
- * const obj = { prop: 'value' };
- * Object.freeze(obj);
- *
- * expect(obj, 'to be frozen'); // ✓ passes
- *
- * // All of these operations will fail silently (or throw in strict mode):
- * obj.prop = 'new value'; // Cannot modify existing property
- * obj.newProp = 'fail'; // Cannot add new property
- * delete obj.prop; // Cannot delete property
- *
- * const regular = {};
- * expect(regular, 'to be frozen'); // ✗ fails - not frozen
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor unknown-to-be-frozen
- * @bupkisAssertionCategory object
- */
-exports.frozenAssertion = (0, create_js_1.createAssertion)(['to be frozen'], (subject) => {
-    if (!isFrozen(subject)) {
-        return {
-            actual: false,
-            expected: true,
-            message: `Expected object to be frozen`,
-        };
-    }
-});
-/**
- * Asserts that an object is extensible using `Object.isExtensible()`.
- *
- * An extensible object allows new properties to be added to it. This is the
- * default state for objects, but can be disabled using
- * `Object.preventExtensions()`, `Object.seal()`, or `Object.freeze()`. This
- * assertion is useful for testing that an object hasn't been made
- * non-extensible by any of these operations.
- *
- * @example
- *
- * ```typescript
- * const obj = {};
- * expect(obj, 'to be extensible'); // ✓ passes - objects are extensible by default
- *
- * obj.newProp = 'value'; // This works
- *
- * Object.preventExtensions(obj);
- * expect(obj, 'to be extensible'); // ✗ fails - no longer extensible
- *
- * const sealed = Object.seal({});
- * expect(sealed, 'to be extensible'); // ✗ fails - sealed objects are non-extensible
- *
- * const frozen = Object.freeze({});
- * expect(frozen, 'to be extensible'); // ✗ fails - frozen objects are non-extensible
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor unknown-to-be-extensible
- * @bupkisAssertionCategory object
- */
-exports.extensibleAssertion = (0, create_js_1.createAssertion)(['to be extensible'], schema_js_1.UnknownSchema.refine((obj) => isExtensible(obj)));
-//# sourceMappingURL=sync-esoteric.js.map

package/dist/assertion/impl/sync-esoteric.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync-esoteric.js","sourceRoot":"","sources":["../../../src/assertion/impl/sync-esoteric.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAEH,6BAAwB;AAExB,gDAAkD;AAClD,gDAIyB;AACzB,6CAA+C;AAE/C,MAAM,EAAE,wBAAwB,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACU,QAAA,sBAAsB,GAAG,IAAA,2BAAe,EACnD,CAAC,CAAC,0BAA0B,EAAE,oBAAoB,CAAC,CAAC,EACpD,4BAAgB,CACjB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACU,QAAA,2BAA2B,GAAG,IAAA,2BAAe,EACxD;IACE,6BAAiB;IACjB,iCAAiC;IACjC,OAAC,CAAC,OAAO,EAAE,CAAC,WAAW,EAAE;CAC1B,EACD,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE;IACf,IAAI,CAAC,wBAAwB,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;QACxD,OAAO;YACL,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,qBAAqB,MAAM,CAAC,OAAO,CAAC,mBAAmB;SACjE,CAAC;IACJ,CAAC;AACH,CAAC,CACF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACU,QAAA,4BAA4B,GAAG,IAAA,2BAAe,EACzD,CAAC,OAAC,CAAC,OAAO,EAAE,CAAC,WAAW,EAAE,EAAE,6BAA6B,EAAE,6BAAiB,CAAC,EAC7E,CAAC,QAAQ,EAAE,GAAG,EAAE,EAAE,CAChB,OAAC,CAAC,MAAM,CACN,CAAC,KAAK,EAAE,EAAE,CACR,IAAA,2BAAe,EAAC,KAAK,CAAC;IACtB,GAAG,IAAI,KAAK;IACZ,CAAC,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,UAAU,EACpD;IACE,KAAK,EAAE,sBAAsB,MAAM,CAAC,GAAG,CAAC,oBAAoB;CAC7D,CACF,CACJ,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACU,QAAA,eAAe,GAAG,IAAA,2BAAe,EAC5C,CAAC,cAAc,CAAC,EAChB,yBAAa,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAC7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACU,QAAA,eAAe,GAAG,IAAA,2BAAe,EAAC,CAAC,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE;IAC3E,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,8BAA8B;SACxC,CAAC;IACJ,CAAC;AACH,CAAC,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACU,QAAA,mBAAmB,GAAG,IAAA,2BAAe,EAChD,CAAC,kBAAkB,CAAC,EACpB,yBAAa,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CACjD,CAAC"}

package/dist/assertion/impl/sync-esoteric.d.cts

@@ -1,191 +0,0 @@
-/**
- * "Esoteric" object assertions that don't fit into more common categories.
- *
- * These are probably less commonly used, but still useful in certain scenarios.
- *
- * @module
- * @groupDescription Esoteric Assertions
- * Individual assertions are documented where they are exported.
- *
- * @showGroups
- */
-import { z } from 'zod';
-/**
- * Asserts that an object has a null prototype (i.e.,
- * `Object.getPrototypeOf(obj) === null`).
- *
- * This is useful for checking if an object was created with
- * `Object.create(null)` or similar patterns that create truly "dictionary-like"
- * objects without any inherited properties.
- *
- * @example
- *
- * ```typescript
- * const obj = Object.create(null);
- * expect(obj, 'to have a null prototype'); // ✓ passes
- *
- * const regular = {};
- * expect(regular, 'to have a null prototype'); // ✗ fails - has Object.prototype
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor object-to-have-a-null-prototype
- * @bupkisAssertionCategory object
- */
-export declare const nullPrototypeAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>;
-/**
- * Asserts that a given property key is an enumerable property of the target
- * object.
- *
- * This checks the `enumerable` descriptor property using
- * `Object.getOwnPropertyDescriptor()`. Only own properties (not inherited ones)
- * are considered, and the property must be enumerable (i.e., would appear in
- * `for...in` loops and `Object.keys()` results).
- *
- * @example
- *
- * ```typescript
- * const obj = { visible: 'value' };
- * Object.defineProperty(obj, 'hidden', {
- *   value: 'secret',
- *   enumerable: false,
- * });
- *
- * expect('visible', 'to be an enumerable property of', obj); // ✓ passes
- * expect('hidden', 'to be an enumerable property of', obj); // ✗ fails - not enumerable
- * expect('toString', 'to be an enumerable property of', obj); // ✗ fails - inherited property
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor string-number-symbol-to-be-an-enumerable-property-of-non-null
- * @bupkisAssertionCategory object
- */
-export declare const enumerablePropertyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, "to be an enumerable property of", z.ZodNonOptional<z.ZodUnknown>], (subject: string | number | symbol, obj: unknown) => {
-    actual: boolean;
-    expected: boolean;
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, import("../assertion-types.js").PhraseLiteralSlot<"to be an enumerable property of">, z.ZodNonOptional<z.ZodUnknown>]>;
-/**
- * Asserts that an object has a specified property that is enumerable.
- *
- * This is an alternative form of {@link enumerablePropertyAssertion} with the
- * object and property key parameters in reverse order. It checks that the given
- * property exists on the object and has its `enumerable` descriptor set to
- * `true` using `Object.getOwnPropertyDescriptor()`. Only own properties (not
- * inherited ones) are considered.
- *
- * @example
- *
- * ```typescript
- * const obj = { visible: 'value' };
- * Object.defineProperty(obj, 'hidden', {
- *   value: 'secret',
- *   enumerable: false,
- * });
- *
- * expect(obj, 'to have enumerable property', 'visible'); // ✓ passes
- * expect(obj, 'to have enumerable property', 'hidden'); // ✗ fails - not enumerable
- * expect(obj, 'to have enumerable property', 'nonexistent'); // ✗ fails - property doesn't exist
- * ```
- *
- * @param subject - The object to check for the enumerable property
- * @param key - The property key to test for enumerability
- * @group Esoteric Assertions
- * @see {@link enumerablePropertyAssertion} - Alternative parameter order
- */
-export declare const enumerablePropertyAssertion2: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodUnknown>, "to have enumerable property", z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => z.ZodCustom<unknown, unknown>, readonly [z.ZodNonOptional<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have enumerable property">, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>;
-/**
- * Asserts that an object is sealed using `Object.isSealed()`.
- *
- * A sealed object cannot have new properties added to it, and all existing
- * properties are marked as non-configurable. However, writable properties can
- * still be modified. This is less restrictive than being frozen but more
- * restrictive than being non-extensible.
- *
- * @example
- *
- * ```typescript
- * const obj = { prop: 'value' };
- * Object.seal(obj);
- *
- * expect(obj, 'to be sealed'); // ✓ passes
- *
- * obj.prop = 'new value'; // This still works
- * obj.newProp = 'fail'; // This will fail (in strict mode)
- *
- * const regular = {};
- * expect(regular, 'to be sealed'); // ✗ fails - not sealed
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor unknown-to-be-sealed
- * @bupkisAssertionCategory object
- */
-export declare const sealedAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], z.ZodUnknown, never>;
-/**
- * Asserts that an object is frozen using `Object.isFrozen()`.
- *
- * A frozen object is completely immutable - no properties can be added,
- * removed, or modified, and no property descriptors can be changed. This is the
- * most restrictive object state. Frozen objects are automatically sealed and
- * non-extensible.
- *
- * @example
- *
- * ```typescript
- * const obj = { prop: 'value' };
- * Object.freeze(obj);
- *
- * expect(obj, 'to be frozen'); // ✓ passes
- *
- * // All of these operations will fail silently (or throw in strict mode):
- * obj.prop = 'new value'; // Cannot modify existing property
- * obj.newProp = 'fail'; // Cannot add new property
- * delete obj.prop; // Cannot delete property
- *
- * const regular = {};
- * expect(regular, 'to be frozen'); // ✗ fails - not frozen
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor unknown-to-be-frozen
- * @bupkisAssertionCategory object
- */
-export declare const frozenAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
-    actual: boolean;
-    expected: boolean;
-    message: string;
-} | undefined, never>;
-/**
- * Asserts that an object is extensible using `Object.isExtensible()`.
- *
- * An extensible object allows new properties to be added to it. This is the
- * default state for objects, but can be disabled using
- * `Object.preventExtensions()`, `Object.seal()`, or `Object.freeze()`. This
- * assertion is useful for testing that an object hasn't been made
- * non-extensible by any of these operations.
- *
- * @example
- *
- * ```typescript
- * const obj = {};
- * expect(obj, 'to be extensible'); // ✓ passes - objects are extensible by default
- *
- * obj.newProp = 'value'; // This works
- *
- * Object.preventExtensions(obj);
- * expect(obj, 'to be extensible'); // ✗ fails - no longer extensible
- *
- * const sealed = Object.seal({});
- * expect(sealed, 'to be extensible'); // ✗ fails - sealed objects are non-extensible
- *
- * const frozen = Object.freeze({});
- * expect(frozen, 'to be extensible'); // ✗ fails - frozen objects are non-extensible
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor unknown-to-be-extensible
- * @bupkisAssertionCategory object
- */
-export declare const extensibleAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], z.ZodUnknown, never>;
-//# sourceMappingURL=sync-esoteric.d.ts.map

package/dist/assertion/impl/sync-esoteric.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync-esoteric.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/sync-esoteric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,sBAAsB,qNAGlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,2BAA2B;;;;6MAevC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,4BAA4B,+cAYxC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,eAAe,6GAG3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe;;;;qBAQ1B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,mBAAmB,iHAG/B,CAAC"}

package/dist/assertion/impl/sync-esoteric.d.ts

@@ -1,191 +0,0 @@
-/**
- * "Esoteric" object assertions that don't fit into more common categories.
- *
- * These are probably less commonly used, but still useful in certain scenarios.
- *
- * @module
- * @groupDescription Esoteric Assertions
- * Individual assertions are documented where they are exported.
- *
- * @showGroups
- */
-import { z } from 'zod';
-/**
- * Asserts that an object has a null prototype (i.e.,
- * `Object.getPrototypeOf(obj) === null`).
- *
- * This is useful for checking if an object was created with
- * `Object.create(null)` or similar patterns that create truly "dictionary-like"
- * objects without any inherited properties.
- *
- * @example
- *
- * ```typescript
- * const obj = Object.create(null);
- * expect(obj, 'to have a null prototype'); // ✓ passes
- *
- * const regular = {};
- * expect(regular, 'to have a null prototype'); // ✗ fails - has Object.prototype
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor object-to-have-a-null-prototype
- * @bupkisAssertionCategory object
- */
-export declare const nullPrototypeAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>;
-/**
- * Asserts that a given property key is an enumerable property of the target
- * object.
- *
- * This checks the `enumerable` descriptor property using
- * `Object.getOwnPropertyDescriptor()`. Only own properties (not inherited ones)
- * are considered, and the property must be enumerable (i.e., would appear in
- * `for...in` loops and `Object.keys()` results).
- *
- * @example
- *
- * ```typescript
- * const obj = { visible: 'value' };
- * Object.defineProperty(obj, 'hidden', {
- *   value: 'secret',
- *   enumerable: false,
- * });
- *
- * expect('visible', 'to be an enumerable property of', obj); // ✓ passes
- * expect('hidden', 'to be an enumerable property of', obj); // ✗ fails - not enumerable
- * expect('toString', 'to be an enumerable property of', obj); // ✗ fails - inherited property
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor string-number-symbol-to-be-an-enumerable-property-of-non-null
- * @bupkisAssertionCategory object
- */
-export declare const enumerablePropertyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, "to be an enumerable property of", z.ZodNonOptional<z.ZodUnknown>], (subject: string | number | symbol, obj: unknown) => {
-    actual: boolean;
-    expected: boolean;
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, import("../assertion-types.js").PhraseLiteralSlot<"to be an enumerable property of">, z.ZodNonOptional<z.ZodUnknown>]>;
-/**
- * Asserts that an object has a specified property that is enumerable.
- *
- * This is an alternative form of {@link enumerablePropertyAssertion} with the
- * object and property key parameters in reverse order. It checks that the given
- * property exists on the object and has its `enumerable` descriptor set to
- * `true` using `Object.getOwnPropertyDescriptor()`. Only own properties (not
- * inherited ones) are considered.
- *
- * @example
- *
- * ```typescript
- * const obj = { visible: 'value' };
- * Object.defineProperty(obj, 'hidden', {
- *   value: 'secret',
- *   enumerable: false,
- * });
- *
- * expect(obj, 'to have enumerable property', 'visible'); // ✓ passes
- * expect(obj, 'to have enumerable property', 'hidden'); // ✗ fails - not enumerable
- * expect(obj, 'to have enumerable property', 'nonexistent'); // ✗ fails - property doesn't exist
- * ```
- *
- * @param subject - The object to check for the enumerable property
- * @param key - The property key to test for enumerability
- * @group Esoteric Assertions
- * @see {@link enumerablePropertyAssertion} - Alternative parameter order
- */
-export declare const enumerablePropertyAssertion2: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodUnknown>, "to have enumerable property", z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => z.ZodCustom<unknown, unknown>, readonly [z.ZodNonOptional<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have enumerable property">, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>;
-/**
- * Asserts that an object is sealed using `Object.isSealed()`.
- *
- * A sealed object cannot have new properties added to it, and all existing
- * properties are marked as non-configurable. However, writable properties can
- * still be modified. This is less restrictive than being frozen but more
- * restrictive than being non-extensible.
- *
- * @example
- *
- * ```typescript
- * const obj = { prop: 'value' };
- * Object.seal(obj);
- *
- * expect(obj, 'to be sealed'); // ✓ passes
- *
- * obj.prop = 'new value'; // This still works
- * obj.newProp = 'fail'; // This will fail (in strict mode)
- *
- * const regular = {};
- * expect(regular, 'to be sealed'); // ✗ fails - not sealed
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor unknown-to-be-sealed
- * @bupkisAssertionCategory object
- */
-export declare const sealedAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], z.ZodUnknown, never>;
-/**
- * Asserts that an object is frozen using `Object.isFrozen()`.
- *
- * A frozen object is completely immutable - no properties can be added,
- * removed, or modified, and no property descriptors can be changed. This is the
- * most restrictive object state. Frozen objects are automatically sealed and
- * non-extensible.
- *
- * @example
- *
- * ```typescript
- * const obj = { prop: 'value' };
- * Object.freeze(obj);
- *
- * expect(obj, 'to be frozen'); // ✓ passes
- *
- * // All of these operations will fail silently (or throw in strict mode):
- * obj.prop = 'new value'; // Cannot modify existing property
- * obj.newProp = 'fail'; // Cannot add new property
- * delete obj.prop; // Cannot delete property
- *
- * const regular = {};
- * expect(regular, 'to be frozen'); // ✗ fails - not frozen
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor unknown-to-be-frozen
- * @bupkisAssertionCategory object
- */
-export declare const frozenAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
-    actual: boolean;
-    expected: boolean;
-    message: string;
-} | undefined, never>;
-/**
- * Asserts that an object is extensible using `Object.isExtensible()`.
- *
- * An extensible object allows new properties to be added to it. This is the
- * default state for objects, but can be disabled using
- * `Object.preventExtensions()`, `Object.seal()`, or `Object.freeze()`. This
- * assertion is useful for testing that an object hasn't been made
- * non-extensible by any of these operations.
- *
- * @example
- *
- * ```typescript
- * const obj = {};
- * expect(obj, 'to be extensible'); // ✓ passes - objects are extensible by default
- *
- * obj.newProp = 'value'; // This works
- *
- * Object.preventExtensions(obj);
- * expect(obj, 'to be extensible'); // ✗ fails - no longer extensible
- *
- * const sealed = Object.seal({});
- * expect(sealed, 'to be extensible'); // ✗ fails - sealed objects are non-extensible
- *
- * const frozen = Object.freeze({});
- * expect(frozen, 'to be extensible'); // ✗ fails - frozen objects are non-extensible
- * ```
- *
- * @group Esoteric Assertions
- * @bupkisAnchor unknown-to-be-extensible
- * @bupkisAssertionCategory object
- */
-export declare const extensibleAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], z.ZodUnknown, never>;
-//# sourceMappingURL=sync-esoteric.d.ts.map

package/dist/assertion/impl/sync-esoteric.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync-esoteric.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/sync-esoteric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,sBAAsB,qNAGlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,2BAA2B;;;;6MAevC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,4BAA4B,+cAYxC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,eAAe,6GAG3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe;;;;qBAQ1B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,mBAAmB,iHAG/B,CAAC"}