@atproto/lex-schema 0.0.11 → 0.0.13

package/src/schema/token.ts

@@ -1,8 +1,25 @@
 import { $type, NsidString, Schema, ValidationContext } from '../core.js'
 
+/**
+ * Schema for Lexicon token values.
+ *
+ * Tokens are named constants in Lexicon, identified by their NSID and hash.
+ * They validate to their string value (e.g., 'app.bsky.feed.defs#requestLess').
+ * TokenSchema instances can also be used as values themselves.
+ *
+ * @template TValue - The token string literal type
+ *
+ * @example
+ * ```ts
+ * const schema = new TokenSchema('app.bsky.feed.defs#requestLess')
+ * schema.validate('app.bsky.feed.defs#requestLess') // success
+ * ```
+ */
 export class TokenSchema<
   const TValue extends string = string,
 > extends Schema<TValue> {
+  readonly type = 'token' as const
+
   constructor(readonly value: TValue) {
     super()
   }
@@ -19,7 +36,7 @@ export class TokenSchema<
     }
 
     if (typeof input !== 'string') {
-      return ctx.issueInvalidType(input, 'token')
+      return ctx.issueUnexpectedType(input, 'token')
     }
 
     return ctx.issueInvalidValue(input, [this.value])
@@ -37,6 +54,38 @@ export class TokenSchema<
   }
 }
 
+/**
+ * Creates a token schema for Lexicon named constants.
+ *
+ * Tokens are used in Lexicon as named constants or enum-like values.
+ * The token instance can be used both as a schema validator and as
+ * the token value itself (it serializes to its string value).
+ *
+ * @param nsid - The NSID part of the token
+ * @param hash - The hash part of the token (defaults to 'main')
+ * @returns A new {@link TokenSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Define tokens
+ * const requestLess = l.token('app.bsky.feed.defs', 'requestLess')
+ * const requestMore = l.token('app.bsky.feed.defs', 'requestMore')
+ *
+ * // Use as a value
+ * console.log(requestLess.toString()) // 'app.bsky.feed.defs#requestLess'
+ *
+ * // Use in union for validation
+ * const feedbackSchema = l.union([requestLess, requestMore])
+ *
+ * // Validate
+ * feedbackSchema.parse('app.bsky.feed.defs#requestLess') // success
+ *
+ * // Token instances can be used as values in other schemas
+ * const feedbackRequest = l.object({
+ *   feedback: requestLess, // Accepts the token value
+ * })
+ * ```
+ */
 /*@__NO_SIDE_EFFECTS__*/
 export function token<
   const N extends NsidString,

package/src/schema/typed-object.ts

@@ -15,6 +15,31 @@ import {
   Validator,
 } from '../core.js'
 
+export type MaybeTypedObject<
+  TType extends $Type,
+  TValue extends { $type?: unknown } = { $type?: unknown },
+> = TValue extends { $type?: TType }
+  ? TValue
+  : $TypedMaybe<Exclude<TValue, Unknown$TypedObject>, TType>
+
+/**
+ * Schema for typed objects in Lexicon unions.
+ *
+ * Typed objects have a `$type` field that identifies which variant they are
+ * in a union. The `$type` can be omitted in input (it's implicit), but if
+ * present, it must match the expected value.
+ *
+ * @template TType - The $type string literal type
+ * @template TShape - The validator type for the object's shape
+ *
+ * @example
+ * ```ts
+ * const schema = new TypedObjectSchema(
+ *   'app.bsky.embed.images#view',
+ *   l.object({ images: l.array(imageSchema) })
+ * )
+ * ```
+ */
 export class TypedObjectSchema<
   const TType extends $Type = $Type,
   const TShape extends Validator<{ [k: string]: unknown }> = any,
@@ -22,6 +47,8 @@ export class TypedObjectSchema<
   $TypedMaybe<InferInput<TShape>, TType>,
   $TypedMaybe<InferOutput<TShape>, TType>
 > {
+  readonly type = 'typedObject' as const
+
   constructor(
     readonly $type: TType,
     readonly schema: TShape,
@@ -29,11 +56,9 @@ export class TypedObjectSchema<
     super()
   }
 
-  isTypeOf<X extends Record<string, unknown>>(
-    value: X,
-  ): value is X extends { $type?: TType }
-    ? X
-    : $TypedMaybe<Exclude<X, Unknown$TypedObject>, TType> {
+  isTypeOf<TValue extends Record<string, unknown>>(
+    value: TValue,
+  ): value is MaybeTypedObject<TType, TValue> {
     return value.$type === undefined || value.$type === this.$type
   }
 
@@ -46,17 +71,21 @@ export class TypedObjectSchema<
     >
   }
 
-  $isTypeOf<X extends Record<string, unknown>>(value: X) {
+  $isTypeOf<TValue extends Record<string, unknown>>(
+    value: TValue,
+  ): value is MaybeTypedObject<TType, TValue> {
     return this.isTypeOf(value)
   }
 
-  $build(input: Omit<InferInput<this>, '$type'>) {
+  $build(
+    input: Omit<InferInput<this>, '$type'>,
+  ): $Typed<InferOutput<this>, TType> {
     return this.build(input)
   }
 
   validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, 'object')
+      return ctx.issueUnexpectedType(input, 'object')
     }
 
     if (
@@ -72,15 +101,51 @@ export class TypedObjectSchema<
 }
 
 /**
+ * Creates a typed object schema for use in Lexicon unions.
+ *
+ * Typed objects are identified by their `$type` field, which combines an NSID
+ * and a hash (e.g., 'app.bsky.embed.images#view'). Used for union variants.
+ *
  * This function offers two overloads:
- * - One that allows creating a {@link TypedObjectSchema}, and infer the output
- *   type from the provided arguments, without requiring to specify any of the
- *   generics. This is useful when you want to define a record without
- *   explicitly defining its interface. This version does not support circular
- *   references, as TypeScript cannot infer types in such cases.
- * - One allows creating a {@link TypedObjectSchema} with an explicitly defined
- *   interface. This will typically be used by codegen (`lex build`) to generate
- *   schemas that work even if they contain circular references.
+ * - One that infers the type from arguments (no circular reference support)
+ * - One with explicit interface for codegen with circular references
+ *
+ * @param nsid - The NSID part of the type (e.g., 'app.bsky.embed.images')
+ * @param hash - The hash part of the type (e.g., 'view'), defaults to 'main'
+ * @param validator - Schema for validating the object properties
+ * @returns A new {@link TypedObjectSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Image embed view
+ * const imageViewSchema = l.typedObject(
+ *   'app.bsky.embed.images',
+ *   'view',
+ *   l.object({
+ *     images: l.array(l.object({
+ *       thumb: l.string(),
+ *       fullsize: l.string(),
+ *       alt: l.string(),
+ *     })),
+ *   })
+ * )
+ *
+ * // Main type (hash defaults to 'main')
+ * const postViewSchema = l.typedObject(
+ *   'app.bsky.feed.defs',
+ *   'postView',
+ *   l.object({ uri: l.string(), cid: l.string(), author: authorSchema })
+ * )
+ *
+ * // Use $isTypeOf to narrow union types
+ * if (imageViewSchema.$isTypeOf(embed)) {
+ *   // embed is narrowed to image view type
+ * }
+ *
+ * // Use $build to construct typed objects
+ * const view = imageViewSchema.$build({ images: [...] })
+ * // view.$type === 'app.bsky.embed.images#view'
+ * ```
  */
 export function typedObject<
   const N extends NsidString,

package/src/schema/typed-ref.ts

@@ -7,6 +7,14 @@ import {
   Validator,
 } from '../core.js'
 
+/**
+ * Interface for validators that have a $type property.
+ *
+ * Used by typed objects and records to identify their type in unions.
+ *
+ * @template TInput - The input type (with optional $type)
+ * @template TOutput - The output type (with non-optional $type)
+ */
 export interface TypedObjectValidator<
   TInput extends { $type?: string } = { $type?: string },
   TOutput extends TInput = TInput,
@@ -14,15 +22,37 @@ export interface TypedObjectValidator<
   $type: NonNullable<TOutput['$type']>
 }
 
+/**
+ * Function type that returns a typed object validator, used for lazy resolution.
+ *
+ * @template TValidator - The typed object validator type
+ */
 export type TypedRefGetter<out TValidator extends TypedObjectValidator> =
   () => TValidator
 
+/**
+ * Schema for referencing typed objects with lazy resolution.
+ *
+ * Used in typed unions to reference typed object schemas. Requires the
+ * `$type` field to be present and match the referenced schema's type.
+ * The referenced schema is resolved lazily to support circular references.
+ *
+ * @template TValidator - The referenced typed object validator type
+ *
+ * @example
+ * ```ts
+ * const ref = new TypedRefSchema(() => imageViewSchema)
+ * // ref.$type === 'app.bsky.embed.images#view'
+ * ```
+ */
 export class TypedRefSchema<
   const TValidator extends TypedObjectValidator = TypedObjectValidator,
 > extends Schema<
   $Typed<InferInput<TValidator>>,
   $Typed<InferOutput<TValidator>>
 > {
+  readonly type = 'typedRef' as const
+
   #getter: TypedRefGetter<TValidator>
 
   constructor(getter: TypedRefGetter<TValidator>) {
@@ -54,6 +84,31 @@ export class TypedRefSchema<
   }
 }
 
+/**
+ * Creates a reference to a typed object schema for use in typed unions.
+ *
+ * Unlike regular `ref()`, this requires the referenced schema to have a
+ * `$type` property, and validates that the input's `$type` matches.
+ *
+ * @param get - Function that returns the typed object validator
+ * @returns A new {@link TypedRefSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Reference to image embed view
+ * const imageRef = l.typedRef(() => imageViewSchema)
+ *
+ * // Use in a typed union
+ * const embedUnion = l.typedUnion([
+ *   l.typedRef(() => imageViewSchema),
+ *   l.typedRef(() => videoViewSchema),
+ *   l.typedRef(() => externalViewSchema),
+ * ], true) // closed union
+ *
+ * // The $type is accessible on the ref
+ * console.log(imageRef.$type) // 'app.bsky.embed.images#view'
+ * ```
+ */
 /*@__NO_SIDE_EFFECTS__*/
 export function typedRef<const TValidator extends TypedObjectValidator>(
   get: TypedRefGetter<TValidator>,

package/src/schema/typed-union.ts

@@ -7,10 +7,32 @@ import {
   ValidationContext,
 } from '../core.js'
 import { lazyProperty } from '../util/lazy-property.js'
+import { TypedObjectSchema } from './typed-object.js'
 import { TypedRefSchema } from './typed-ref.js'
 
+/**
+ * Schema for Lexicon typed unions (unions discriminated by $type).
+ *
+ * Typed unions are collections of typed objects identified by their `$type`
+ * field. Can be "open" (accept unknown types) or "closed" (only accept
+ * known types).
+ *
+ * @template TValidators - Tuple of {@link TypedRefSchema} or {@link TypedObjectSchema} instances
+ * @template TClosed - Whether the union is closed (rejects unknown $types)
+ *
+ * @example
+ * ```ts
+ * const embedUnion = new TypedUnionSchema([
+ *   l.typedRef(() => imageSchema),
+ *   l.typedRef(() => videoSchema),
+ * ], true) // closed - only accepts images and videos
+ * ```
+ */
 export class TypedUnionSchema<
-  const TValidators extends readonly TypedRefSchema[] = [],
+  const TValidators extends readonly (
+    | TypedRefSchema
+    | TypedObjectSchema
+  )[] = [],
   const TClosed extends boolean = boolean,
 > extends Schema<
   TClosed extends true
@@ -20,13 +42,16 @@ export class TypedUnionSchema<
     ? InferOutput<TValidators[number]>
     : InferOutput<TValidators[number]> | Unknown$TypedObject
 > {
+  readonly type = 'typedUnion' as const
+
   constructor(
     protected readonly validators: TValidators,
     public readonly closed: TClosed,
   ) {
     // @NOTE In order to avoid circular dependency issues, we don't access the
     // refs's schema (or $type) here. Instead, we access them lazily when first
-    // needed.
+    // needed. The biggest issue with this strategy is that we can't throw
+    // early if the refs contain multiple refs with the same $type.
 
     super()
   }
@@ -44,7 +69,7 @@ export class TypedUnionSchema<
 
   validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isPlainObject(input) || !('$type' in input)) {
-      return ctx.issueInvalidType(input, '$typed')
+      return ctx.issueUnexpectedType(input, '$typed')
     }
 
     const { $type } = input
@@ -66,6 +91,36 @@ export class TypedUnionSchema<
   }
 }
 
+/**
+ * Creates a typed union schema for Lexicon unions.
+ *
+ * Typed unions discriminate variants by their `$type` field. Can be open
+ * (accepts unknown types, useful for extensibility) or closed (strict).
+ *
+ * @param refs - Array of typed refs for the union variants
+ * @param closed - Whether to reject unknown $type values
+ * @returns A new {@link TypedUnionSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Closed union - only accepts known types
+ * const embedSchema = l.typedUnion([
+ *   l.typedRef(() => imageViewSchema),
+ *   l.typedRef(() => videoViewSchema),
+ *   l.typedRef(() => externalViewSchema),
+ * ], true)
+ *
+ * // Open union - accepts unknown types for forward compatibility
+ * const feedItemSchema = l.typedUnion([
+ *   l.typedRef(() => postSchema),
+ *   l.typedRef(() => repostSchema),
+ * ], false) // unknown types pass through
+ *
+ * // Get all known $types
+ * console.log(embedSchema.$types)
+ * // ['app.bsky.embed.images#view', 'app.bsky.embed.video#view', ...]
+ * ```
+ */
 /*@__NO_SIDE_EFFECTS__*/
 export function typedUnion<
   const R extends readonly TypedRefSchema[],

package/src/schema/union.ts

@@ -8,14 +8,37 @@ import {
   Validator,
 } from '../core.js'
 
+/**
+ * Type representing a non-empty tuple of validators for union schemas.
+ *
+ * Requires at least one validator in the tuple.
+ */
 export type UnionSchemaValidators = readonly [Validator, ...Validator[]]
 
+/**
+ * Schema for validating values that match one of several possible schemas.
+ *
+ * Tries each validator in order until one succeeds. If all validators fail,
+ * returns a combined error from all attempts.
+ *
+ * @template TValidators - Tuple type of the validators in the union
+ *
+ * @example
+ * ```ts
+ * const schema = new UnionSchema([l.string(), l.integer()])
+ * schema.validate('hello') // success
+ * schema.validate(42)      // success
+ * schema.validate(true)    // fails
+ * ```
+ */
 export class UnionSchema<
   const TValidators extends UnionSchemaValidators = any,
 > extends Schema<
   InferInput<TValidators[number]>,
   InferOutput<TValidators[number]>
 > {
+  readonly type = 'union' as const
+
   constructor(protected readonly validators: TValidators) {
     super()
   }
@@ -34,6 +57,30 @@ export class UnionSchema<
   }
 }
 
+/**
+ * Creates a union schema that accepts values matching any of the provided schemas.
+ *
+ * Validators are tried in order. Use `discriminatedUnion()` for better
+ * performance when discriminating on a known property.
+ *
+ * @param validators - Non-empty array of validators to try
+ * @returns A new {@link UnionSchema} instance
+ *
+ * @example
+ * ```ts
+ * // String or number
+ * const stringOrNumber = l.union([l.string(), l.integer()])
+ *
+ * // Nullable value
+ * const nullableString = l.union([l.string(), l.null()])
+ *
+ * // Multiple object types
+ * const mediaSchema = l.union([
+ *   l.object({ type: l.literal('image'), url: l.string() }),
+ *   l.object({ type: l.literal('video'), url: l.string(), duration: l.integer() }),
+ * ])
+ * ```
+ */
 /*@__NO_SIDE_EFFECTS__*/
 export function union<const TValidators extends UnionSchemaValidators>(
   validators: TValidators,

package/src/schema/unknown.ts

@@ -1,12 +1,47 @@
 import { Schema, ValidationContext } from '../core.js'
 import { memoizedOptions } from '../util/memoize.js'
 
+/**
+ * Schema that accepts any value without validation.
+ *
+ * Passes through any input unchanged. Use sparingly as it bypasses
+ * type safety. Useful for dynamic data or when the schema is not
+ * known at compile time.
+ *
+ * @example
+ * ```ts
+ * const schema = new UnknownSchema()
+ * schema.validate(anything) // always succeeds
+ * ```
+ */
 export class UnknownSchema extends Schema<unknown> {
+  readonly type = 'unknown' as const
+
   validateInContext(input: unknown, ctx: ValidationContext) {
     return ctx.success(input)
   }
 }
 
+/**
+ * Creates an unknown schema that accepts any value.
+ *
+ * The value passes through without any validation or transformation.
+ * Use this when you need to accept arbitrary data.
+ *
+ * @returns A new {@link UnknownSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Accept any value
+ * const anyDataSchema = l.unknown()
+ *
+ * // In an object with a dynamic field
+ * const flexibleSchema = l.object({
+ *   type: l.string(),
+ *   data: l.unknown(),
+ * })
+ * ```
+ */
 export const unknown = /*#__PURE__*/ memoizedOptions(function () {
   return new UnknownSchema()
 })

package/src/schema/with-default.ts

@@ -6,9 +6,27 @@ import {
   Validator,
 } from '../core.js'
 
+/**
+ * Schema wrapper that provides a default value when the input is undefined.
+ *
+ * In parse mode, when the input is `undefined`, the default value is used
+ * instead. In validate mode, undefined values pass through unchanged (the
+ * default is not applied).
+ *
+ * @template TValidator - The wrapped validator type
+ *
+ * @example
+ * ```ts
+ * const schema = new WithDefaultSchema(l.integer(), 0)
+ * schema.parse(undefined) // 0
+ * schema.parse(42)        // 42
+ * ```
+ */
 export class WithDefaultSchema<
   const TValidator extends Validator,
 > extends Schema<InferInput<TValidator>, InferOutput<TValidator>> {
+  readonly type = 'withDefault' as const
+
   constructor(
     readonly validator: TValidator,
     readonly defaultValue: InferInput<TValidator>,
@@ -27,6 +45,34 @@ export class WithDefaultSchema<
   }
 }
 
+/**
+ * Creates a schema that applies a default value when the input is undefined.
+ *
+ * Commonly used with `optional()` to provide fallback values for missing
+ * properties. The default value is validated against the schema.
+ *
+ * @param validator - The validator for the value
+ * @param defaultValue - The default value to use when input is undefined
+ * @returns A new {@link WithDefaultSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Integer with default
+ * const countSchema = l.withDefault(l.integer(), 0)
+ * countSchema.parse(undefined) // 0
+ * countSchema.parse(5)         // 5
+ *
+ * // Commonly combined with optional in objects
+ * const settingsSchema = l.object({
+ *   theme: l.optional(l.withDefault(l.string(), 'light')),
+ *   pageSize: l.optional(l.withDefault(l.integer(), 25)),
+ * })
+ * settingsSchema.parse({}) // { theme: 'light', pageSize: 25 }
+ *
+ * // Boolean with default
+ * const enabledSchema = l.withDefault(l.boolean(), false)
+ * ```
+ */
 export function withDefault<const TValidator extends Validator>(
   validator: TValidator,
   defaultValue: InferInput<TValidator>,

package/src/schema.ts

@@ -7,13 +7,14 @@ export * from './schema/cid.js'
 export * from './schema/dict.js'
 export * from './schema/enum.js'
 export * from './schema/integer.js'
+export * from './schema/lex-map.js'
+export * from './schema/lex-value.js'
 export * from './schema/literal.js'
 export * from './schema/never.js'
 export * from './schema/null.js'
 export * from './schema/object.js'
 export * from './schema/regexp.js'
 export * from './schema/string.js'
-export * from './schema/unknown-object.js'
 export * from './schema/unknown.js'
 
 // Composite Types

package/src/util/if-any.ts

@@ -0,0 +1,3 @@
+export type IfAny<T, TrueValue, FalseValue> = 0 extends 1 & T
+  ? TrueValue
+  : FalseValue

package/dist/schema/unknown-object.d.ts

@@ -1,8 +0,0 @@
-import { LexMap } from '@atproto/lex-data';
-import { Schema, ValidationContext } from '../core.js';
-export type UnknownObject = LexMap;
-export declare class UnknownObjectSchema extends Schema<UnknownObject> {
-    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<LexMap>;
-}
-export declare const unknownObject: () => UnknownObjectSchema;
-//# sourceMappingURL=unknown-object.d.ts.map

package/dist/schema/unknown-object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unknown-object.d.ts","sourceRoot":"","sources":["../../src/schema/unknown-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD,MAAM,MAAM,aAAa,GAAG,MAAM,CAAA;AAElC,qBAAa,mBAAoB,SAAQ,MAAM,CAAC,aAAa,CAAC;IAC5D,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAED,eAAO,MAAM,aAAa,2BAExB,CAAA"}

package/dist/schema/unknown-object.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unknownObject = exports.UnknownObjectSchema = void 0;
-const lex_data_1 = require("@atproto/lex-data");
-const core_js_1 = require("../core.js");
-const memoize_js_1 = require("../util/memoize.js");
-class UnknownObjectSchema extends core_js_1.Schema {
-    validateInContext(input, ctx) {
-        if ((0, lex_data_1.isLexMap)(input)) {
-            return ctx.success(input);
-        }
-        return ctx.issueInvalidType(input, 'unknown');
-    }
-}
-exports.UnknownObjectSchema = UnknownObjectSchema;
-exports.unknownObject = (0, memoize_js_1.memoizedOptions)(function () {
-    return new UnknownObjectSchema();
-});
-//# sourceMappingURL=unknown-object.js.map

package/dist/schema/unknown-object.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unknown-object.js","sourceRoot":"","sources":["../../src/schema/unknown-object.ts"],"names":[],"mappings":";;;AAAA,gDAAoD;AACpD,wCAAsD;AACtD,mDAAoD;AAIpD,MAAa,mBAAoB,SAAQ,gBAAqB;IAC5D,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,IAAA,mBAAQ,EAAC,KAAK,CAAC,EAAE,CAAC;YACpB,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;QAED,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IAC/C,CAAC;CACF;AARD,kDAQC;AAEY,QAAA,aAAa,GAAiB,IAAA,4BAAe,EAAC;IACzD,OAAO,IAAI,mBAAmB,EAAE,CAAA;AAClC,CAAC,CAAC,CAAA","sourcesContent":["import { LexMap, isLexMap } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport type UnknownObject = LexMap\n\nexport class UnknownObjectSchema extends Schema<UnknownObject> {\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (isLexMap(input)) {\n      return ctx.success(input)\n    }\n\n    return ctx.issueInvalidType(input, 'unknown')\n  }\n}\n\nexport const unknownObject = /*#__PURE__*/ memoizedOptions(function () {\n  return new UnknownObjectSchema()\n})\n"]}

package/src/schema/unknown-object.ts

@@ -1,19 +0,0 @@
-import { LexMap, isLexMap } from '@atproto/lex-data'
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-export type UnknownObject = LexMap
-
-export class UnknownObjectSchema extends Schema<UnknownObject> {
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (isLexMap(input)) {
-      return ctx.success(input)
-    }
-
-    return ctx.issueInvalidType(input, 'unknown')
-  }
-}
-
-export const unknownObject = /*#__PURE__*/ memoizedOptions(function () {
-  return new UnknownObjectSchema()
-})