functype 0.51.0 → 0.53.0

package/dist/{index-B5zYifBQ.d.ts → index-Di7IFeuy.d.ts}

@@ -1803,142 +1803,6 @@ declare const Validation: (<T extends Type>(rule: ValidationRule) => Validator<T
   form: <T extends Record<string, Type>>(schema: { [K in keyof T]: Validator<T[K]> }, data: Record<string, unknown>) => FormValidation<T>;
 };
 //#endregion
-//#region src/foldable/index.d.ts
-/**
- * Structural type for sum types that support pattern-match fold (Option, Either, Try, etc.).
- * Uses duck typing so any type with the right fold signature works, without requiring a shared interface.
- */
-type PatternFoldable<A> = {
-  fold<B>(onEmpty: () => B, onValue: (value: A) => B): B;
-};
-/**
- * Utility functions for working with sum-type Foldable data structures.
- * These utilities use pattern-match fold semantics and are designed for
- * sum types (Option, Either, Try) — not collections.
- */
-declare const FoldableUtils: {
-  /**
-   * Converts a sum type to an Option
-   *
-   * @param foldable - The sum type to convert
-   * @returns An Option containing the value, or None if empty
-   */
-  toOption: <A extends Type>(foldable: PatternFoldable<A>) => Option<A>;
-  /**
-   * Converts a sum type to a List
-   *
-   * @param foldable - The sum type to convert
-   * @returns A List containing the value(s), or empty List if empty
-   */
-  toList: <A extends Type>(foldable: PatternFoldable<A>) => List<A>;
-  /**
-   * Converts a sum type to an Either
-   *
-   * @param foldable - The sum type to convert
-   * @param left - The value to use for Left if empty
-   * @returns Either.Right with the value if non-empty, or Either.Left with left if empty
-   */
-  toEither: <A extends Type, E>(foldable: PatternFoldable<A>, left: E) => Either<E, A>;
-  /**
-   * Checks if the sum type is empty
-   *
-   * @param foldable - The sum type to check
-   * @returns true if empty, false otherwise
-   */
-  isEmpty: <A extends Type>(foldable: PatternFoldable<A>) => boolean;
-  /**
-   * Calculates the size of the sum type (0 or 1)
-   *
-   * @param foldable - The sum type to measure
-   * @returns The size (0 if empty, 1 if non-empty)
-   */
-  size: <A extends Type>(foldable: PatternFoldable<A>) => number;
-};
-//#endregion
-//#region src/hkt/index.d.ts
-/**
- * Type function for representing higher-kinded types
- */
-type Kind<F, A> = F extends ((arg: infer T) => infer R) ? R : never;
-/**
- * Type constructors for common Functype data types
- */
-type OptionKind = <A>(a: A) => Option<A>;
-type ListKind = <A>(a: A) => List<A>;
-type EitherKind<E> = <A>(a: A) => Either<E, A>;
-type TryKind = <A>(a: A) => Try<A>;
-/**
- * Generic container types for type-safe operations
- * @internal
- */
-type Mappable<T> = {
-  map<U>(f: (value: T) => U): unknown;
-};
-/**
- * @internal
- */
-type Flattenable = {
-  flatten(): unknown;
-};
-/**
- * @internal
- */
-type FlatMappable<T> = {
-  flatMap<U>(f: (value: T) => unknown): unknown;
-};
-/**
- * Universal type that includes all potential return types from the HKT functions
- * Used to avoid 'any' usage which the linter prohibits
- */
-type UniversalContainer = Option<unknown> | List<unknown> | Either<unknown, unknown> | Try<unknown>;
-/**
- * HKT provides utilities for working with higher-kinded types
- * This allows writing generic code that works across different
- * container types like Option, List, Either, etc.
- */
-declare const HKT: {
-  (): {
-    _tag: string;
-    map: <F, A, B>(fa: unknown, f: (a: A) => B) => unknown;
-    flatten: <F, A>(ffa: unknown) => unknown;
-    flatMap: <F, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
-    ap: <F, A, B>(ff: unknown, fa: unknown) => unknown;
-    sequence: <F, G, A>(fga: unknown) => unknown;
-    traverse: <F, G, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
-    _type: string;
-  };
-  map<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => B): unknown;
-  flatten<F = unknown, A = unknown>(ffa: unknown): unknown;
-  flatMap<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
-  ap<F = unknown, A = unknown, B = unknown>(ff: unknown, fa: unknown): unknown;
-  sequence<F = unknown, G = unknown, A = unknown>(fga: unknown): unknown;
-  traverse<F = unknown, G = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
-  isOption: <T extends Type>(value: unknown) => value is Option<T> & Mappable<T> & FlatMappable<T>;
-  isList: <T extends Type>(value: unknown) => value is List<T> & Mappable<T> & Flattenable & FlatMappable<T>;
-  isEither: <E extends Type, A extends Type>(value: unknown) => value is Either<E, A> & Mappable<A> & FlatMappable<A>;
-  isTry: <T extends Type>(value: unknown) => value is Try<T> & Mappable<T> & FlatMappable<T>;
-};
-//#endregion
-//#region src/identity/Identity.d.ts
-type Identity<T> = {
-  id: T;
-  isSame?: (other: Identity<T>) => boolean;
-};
-declare const Identity: (<T>(value: T) => Identity<T>) & {
-  /**
-   * Creates an Identity. Alias for Identity constructor.
-   * @param value - The value to wrap
-   * @returns Identity instance
-   */
-  of: <T>(value: T) => Identity<T>;
-  /**
-   * Creates an Identity. Same as of.
-   * @param value - The value to wrap
-   * @returns Identity instance
-   */
-  pure: <T>(value: T) => Identity<T>;
-};
-//#endregion
 //#region src/io/Tag.d.ts
 /**
  * Tag module - service identifiers for dependency injection.
@@ -3308,6 +3172,238 @@ declare const TestContext: {
   withClock: () => TestContext<TestClock>;
 };
 //#endregion
+//#region src/fetch/HttpClient.d.ts
+interface HttpClientConfig {
+  readonly baseUrl?: string;
+  readonly defaultHeaders?: Record<string, string>;
+  readonly fetch?: typeof globalThis.fetch;
+}
+declare const HttpClient: Tag<HttpClientConfig>;
+//#endregion
+//#region src/fetch/HttpError.d.ts
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+type NetworkError = {
+  readonly _tag: "NetworkError";
+  readonly url: string;
+  readonly method: HttpMethod;
+  readonly cause: unknown;
+};
+type HttpStatusError = {
+  readonly _tag: "HttpStatusError";
+  readonly url: string;
+  readonly method: HttpMethod;
+  readonly status: number;
+  readonly statusText: string;
+  readonly body: string;
+};
+type DecodeError = {
+  readonly _tag: "DecodeError";
+  readonly url: string;
+  readonly method: HttpMethod;
+  readonly body: string;
+  readonly cause: unknown;
+};
+type HttpError = NetworkError | HttpStatusError | DecodeError;
+declare const HttpError: {
+  readonly _tag: "HttpError";
+} & {
+  networkError: (url: string, method: HttpMethod, cause: unknown) => NetworkError;
+  httpStatusError: (url: string, method: HttpMethod, status: number, statusText: string, body: string) => HttpStatusError;
+  decodeError: (url: string, method: HttpMethod, body: string, cause: unknown) => DecodeError;
+  isNetworkError: (error: HttpError) => error is NetworkError;
+  isHttpStatusError: (error: HttpError) => error is HttpStatusError;
+  isDecodeError: (error: HttpError) => error is DecodeError;
+  match: <T>(error: HttpError, patterns: {
+    readonly NetworkError: (e: NetworkError) => T;
+    readonly HttpStatusError: (e: HttpStatusError) => T;
+    readonly DecodeError: (e: DecodeError) => T;
+  }) => T;
+};
+//#endregion
+//#region src/fetch/HttpRequest.d.ts
+type ParseMode = "json" | "text" | "blob" | "arrayBuffer" | "raw";
+interface HttpRequestOptions {
+  readonly url: string;
+  readonly method: HttpMethod;
+  readonly headers?: Record<string, string>;
+  readonly body?: unknown;
+  readonly signal?: AbortSignal;
+  readonly parseAs?: ParseMode;
+}
+interface HttpMethodOptions {
+  readonly headers?: Record<string, string>;
+  readonly body?: unknown;
+  readonly signal?: AbortSignal;
+  readonly parseAs?: ParseMode;
+}
+interface HttpResponse<T> {
+  readonly data: T;
+  readonly status: number;
+  readonly statusText: string;
+  readonly headers: Headers;
+}
+//#endregion
+//#region src/fetch/Http.d.ts
+type HttpMethods = {
+  readonly request: <T>(options: HttpRequestOptions) => IO<never, HttpError, HttpResponse<T>>;
+  readonly get: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  readonly post: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  readonly put: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  readonly patch: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  readonly delete: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  readonly head: (url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<void>>;
+  readonly options: (url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<void>>;
+};
+declare const Http: {
+  readonly _tag: "Http";
+} & {
+  request: <T>(options: HttpRequestOptions) => IO<never, HttpError, HttpResponse<T>>;
+  get: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  post: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  put: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  patch: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  delete: <T>(url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<T>>;
+  head: (url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<void>>;
+  options: (url: string, options?: HttpMethodOptions) => IO<never, HttpError, HttpResponse<void>>;
+  client: (config: HttpClientConfig) => HttpMethods;
+};
+//#endregion
+//#region src/foldable/index.d.ts
+/**
+ * Structural type for sum types that support pattern-match fold (Option, Either, Try, etc.).
+ * Uses duck typing so any type with the right fold signature works, without requiring a shared interface.
+ */
+type PatternFoldable<A> = {
+  fold<B>(onEmpty: () => B, onValue: (value: A) => B): B;
+};
+/**
+ * Utility functions for working with sum-type Foldable data structures.
+ * These utilities use pattern-match fold semantics and are designed for
+ * sum types (Option, Either, Try) — not collections.
+ */
+declare const FoldableUtils: {
+  /**
+   * Converts a sum type to an Option
+   *
+   * @param foldable - The sum type to convert
+   * @returns An Option containing the value, or None if empty
+   */
+  toOption: <A extends Type>(foldable: PatternFoldable<A>) => Option<A>;
+  /**
+   * Converts a sum type to a List
+   *
+   * @param foldable - The sum type to convert
+   * @returns A List containing the value(s), or empty List if empty
+   */
+  toList: <A extends Type>(foldable: PatternFoldable<A>) => List<A>;
+  /**
+   * Converts a sum type to an Either
+   *
+   * @param foldable - The sum type to convert
+   * @param left - The value to use for Left if empty
+   * @returns Either.Right with the value if non-empty, or Either.Left with left if empty
+   */
+  toEither: <A extends Type, E>(foldable: PatternFoldable<A>, left: E) => Either<E, A>;
+  /**
+   * Checks if the sum type is empty
+   *
+   * @param foldable - The sum type to check
+   * @returns true if empty, false otherwise
+   */
+  isEmpty: <A extends Type>(foldable: PatternFoldable<A>) => boolean;
+  /**
+   * Calculates the size of the sum type (0 or 1)
+   *
+   * @param foldable - The sum type to measure
+   * @returns The size (0 if empty, 1 if non-empty)
+   */
+  size: <A extends Type>(foldable: PatternFoldable<A>) => number;
+};
+//#endregion
+//#region src/hkt/index.d.ts
+/**
+ * Type function for representing higher-kinded types
+ */
+type Kind<F, A> = F extends ((arg: infer T) => infer R) ? R : never;
+/**
+ * Type constructors for common Functype data types
+ */
+type OptionKind = <A>(a: A) => Option<A>;
+type ListKind = <A>(a: A) => List<A>;
+type EitherKind<E> = <A>(a: A) => Either<E, A>;
+type TryKind = <A>(a: A) => Try<A>;
+/**
+ * Generic container types for type-safe operations
+ * @internal
+ */
+type Mappable<T> = {
+  map<U>(f: (value: T) => U): unknown;
+};
+/**
+ * @internal
+ */
+type Flattenable = {
+  flatten(): unknown;
+};
+/**
+ * @internal
+ */
+type FlatMappable<T> = {
+  flatMap<U>(f: (value: T) => unknown): unknown;
+};
+/**
+ * Universal type that includes all potential return types from the HKT functions
+ * Used to avoid 'any' usage which the linter prohibits
+ */
+type UniversalContainer = Option<unknown> | List<unknown> | Either<unknown, unknown> | Try<unknown>;
+/**
+ * HKT provides utilities for working with higher-kinded types
+ * This allows writing generic code that works across different
+ * container types like Option, List, Either, etc.
+ */
+declare const HKT: {
+  (): {
+    _tag: string;
+    map: <F, A, B>(fa: unknown, f: (a: A) => B) => unknown;
+    flatten: <F, A>(ffa: unknown) => unknown;
+    flatMap: <F, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
+    ap: <F, A, B>(ff: unknown, fa: unknown) => unknown;
+    sequence: <F, G, A>(fga: unknown) => unknown;
+    traverse: <F, G, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
+    _type: string;
+  };
+  map<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => B): unknown;
+  flatten<F = unknown, A = unknown>(ffa: unknown): unknown;
+  flatMap<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
+  ap<F = unknown, A = unknown, B = unknown>(ff: unknown, fa: unknown): unknown;
+  sequence<F = unknown, G = unknown, A = unknown>(fga: unknown): unknown;
+  traverse<F = unknown, G = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
+  isOption: <T extends Type>(value: unknown) => value is Option<T> & Mappable<T> & FlatMappable<T>;
+  isList: <T extends Type>(value: unknown) => value is List<T> & Mappable<T> & Flattenable & FlatMappable<T>;
+  isEither: <E extends Type, A extends Type>(value: unknown) => value is Either<E, A> & Mappable<A> & FlatMappable<A>;
+  isTry: <T extends Type>(value: unknown) => value is Try<T> & Mappable<T> & FlatMappable<T>;
+};
+//#endregion
+//#region src/identity/Identity.d.ts
+type Identity<T> = {
+  id: T;
+  isSame?: (other: Identity<T>) => boolean;
+};
+declare const Identity: (<T>(value: T) => Identity<T>) & {
+  /**
+   * Creates an Identity. Alias for Identity constructor.
+   * @param value - The value to wrap
+   * @returns Identity instance
+   */
+  of: <T>(value: T) => Identity<T>;
+  /**
+   * Creates an Identity. Same as of.
+   * @param value - The value to wrap
+   * @returns Identity instance
+   */
+  pure: <T>(value: T) => Identity<T>;
+};
+//#endregion
 //#region src/lazy/Lazy.d.ts
 /**
  * Lazy type module
@@ -3574,12 +3670,22 @@ interface Traversable<A extends Type> extends AsyncMonad<A> {
   reduceRight(f: (b: A, a: A) => A): A;
 }
 //#endregion
-//#region src/map/Map.d.ts
+//#region src/traversable/KVTraversable.d.ts
 /**
- * A traversable interface for map that excludes map and flatMap operations
+ * A traversable interface for key-value containers that excludes map, flatMap,
+ * flatMapAsync, and ap operations.
+ *
+ * Key-value containers (Map, Obj) cannot satisfy Functor's unconstrained
+ * `map<B extends Type>` because their type parameter is constrained
+ * (e.g., to Record or Tuple pairs). These containers redefine map/flatMap
+ * with their own tighter constraints.
+ *
+ * @typeParam A - The element type of the traversable
  */
-type SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, "map" | "flatMap" | "flatMapAsync" | "ap">;
-interface Map$1<K, V> extends SafeTraversable<K, V>, Collection<Tuple<[K, V]>>, Typeable<"Map">, Serializable<[K, V][]>, Pipe<[K, V][]>, Foldable<Tuple<[K, V]>>, Iterable<[K, V]> {
+type KVTraversable<A> = Omit<Traversable<A>, "map" | "flatMap" | "flatMapAsync" | "ap">;
+//#endregion
+//#region src/map/Map.d.ts
+interface Map$1<K, V> extends KVTraversable<Tuple<[K, V]>>, Collection<Tuple<[K, V]>>, Typeable<"Map">, Serializable<[K, V][]>, Pipe<[K, V][]>, Foldable<Tuple<[K, V]>>, Iterable<[K, V]> {
   readonly [Symbol.toStringTag]: string;
   readonly _tag: "Map";
   add(item: Tuple<[K, V]>): Map$1<K, V>;
@@ -3696,6 +3802,191 @@ declare const MatchableUtils: {
   when: <A, R>(predicate: (value: A) => boolean, handler: (value: A) => R) => (value: A) => R | undefined;
 };
 //#endregion
+//#region src/obj/Obj.d.ts
+/**
+ * Obj type module
+ * @module Obj
+ * @category Core
+ */
+/**
+ * The Obj type wraps a plain JavaScript object and provides fluent,
+ * immutable operations for building and transforming objects.
+ *
+ * @typeParam T - The record type of the contained object
+ *
+ * @example
+ * ```typescript
+ * // Build HTTP headers immutably with conditional auth
+ * const headers = Obj({ "User-Agent": userAgent })
+ *   .assign(options.headers)
+ *   .when(requiresAuth, { Authorization: `Bearer ${token}` })
+ *   .value()
+ *
+ * // Fluent object construction
+ * Obj.of({ name: "John" })
+ *   .set("age", 31)
+ *   .merge({ city: "NYC" })
+ *   .value()
+ * ```
+ */
+interface Obj<T extends Record<string, Type>> extends Omit<Functype<T, "Obj">, "map" | "flatMap" | "flatMapAsync" | "ap">, Promisable<T>, Doable<T>, Reshapeable<T> {
+  /** The contained object value */
+  readonly data: T;
+  /**
+   * Maps the contained object to a new object using the provided function
+   * @param f - The mapping function (must return a Record)
+   * @returns A new Obj containing the mapped value
+   */
+  map<U extends Record<string, Type>>(f: (value: T) => U): Obj<U>;
+  /**
+   * FlatMaps the contained object using a function that returns an Obj
+   * @param f - The flatMap function
+   * @returns The Obj returned by f
+   */
+  flatMap<U extends Record<string, Type>>(f: (value: T) => Obj<U>): Obj<U>;
+  /**
+   * Async flatMap for the contained object
+   * @param f - The async flatMap function
+   * @returns A Promise of the Obj returned by f
+   */
+  flatMapAsync<U extends Record<string, Type>>(f: (value: T) => PromiseLike<Obj<U>>): PromiseLike<Obj<U>>;
+  /**
+   * Applies a wrapped function to the contained object
+   * @param ff - An Obj containing a function from T to U
+   * @returns A new Obj containing the result
+   */
+  ap<U extends Record<string, Type>>(ff: Obj<Record<string, Type>>): Obj<U>;
+  /**
+   * Get a value by key, returning Option
+   * @param key - The key to look up
+   * @returns Option containing the value if present
+   */
+  get<K extends keyof T>(key: K): Option<T[K]>;
+  /**
+   * Set a single key to a new value, returning a new Obj
+   * @param key - The key to set (must exist in T)
+   * @param value - The value to set
+   * @returns A new Obj with the updated key
+   */
+  set<K extends keyof T>(key: K, value: T[K]): Obj<T>;
+  /**
+   * Merge a partial of the same shape (no new keys)
+   * @param partial - Partial object to merge
+   * @returns A new Obj with merged values
+   */
+  assign(partial: Partial<T>): Obj<T>;
+  /**
+   * Merge with a potentially wider type (can add new keys)
+   * @param other - Object to merge in
+   * @returns A new Obj with the merged type
+   */
+  merge<U extends Record<string, Type>>(other: U): Obj<T & U>;
+  /**
+   * Conditionally merge a partial based on a boolean or predicate
+   * @param condition - Boolean or predicate function
+   * @param partial - Partial to merge if condition is true
+   * @returns A new Obj, with or without the merge applied
+   */
+  when(condition: boolean | (() => boolean), partial: Partial<T>): Obj<T>;
+  /**
+   * Return a new Obj without the specified keys
+   * @param keys - Keys to remove
+   * @returns A new Obj without the specified keys
+   */
+  omit<K extends keyof T>(...keys: K[]): Obj<Omit<T, K>>;
+  /**
+   * Return a new Obj with only the specified keys
+   * @param keys - Keys to keep
+   * @returns A new Obj with only the specified keys
+   */
+  pick<K extends keyof T>(...keys: K[]): Obj<Pick<T, K>>;
+  /**
+   * Return a List of keys
+   * @returns List of string keys
+   */
+  keys(): List<string>;
+  /**
+   * Return a List of values
+   * @returns List of values
+   */
+  values(): List<T[keyof T]>;
+  /**
+   * Return a List of [key, value] Tuples
+   * @returns List of key-value Tuples
+   */
+  entries(): List<ReturnType<typeof Tuple<[string, T[keyof T]]>>>;
+  /**
+   * Unwrap to the plain object
+   * @returns The contained plain object
+   */
+  value(): T;
+  /**
+   * Check if a key exists
+   * @param key - The key to check
+   * @returns true if the key exists
+   */
+  has<K extends keyof T>(key: K): boolean;
+  /**
+   * Pattern match fold — applies onEmpty if empty, onValue if non-empty
+   * @param onEmpty - Handler for empty Obj
+   * @param onValue - Handler for non-empty Obj
+   * @returns The result of the matching handler
+   */
+  fold<U extends Type>(onEmpty: () => U, onValue: (value: T) => U): U;
+  /**
+   * Returns a string representation of this Obj
+   * @returns A string representation
+   */
+  toString(): string;
+}
+/**
+ * Obj - Immutable object wrapper with fluent operations.
+ *
+ * Wraps plain JavaScript objects and provides chainable, immutable
+ * operations for building and transforming them. Implements the full
+ * Functype interface (Functor, Foldable, Serializable, Matchable, etc.).
+ *
+ * @example
+ * ```typescript
+ * // Build headers with conditional auth
+ * const headers = Obj({ "User-Agent": "MyApp/1.0" })
+ *   .assign(options.headers)
+ *   .when(requiresAuth, { Authorization: `Bearer ${token}` })
+ *   .value()
+ *
+ * // Object manipulation
+ * const user = Obj({ name: "John", age: 30, role: "admin" })
+ * user.pick("name", "role").value()  // { name: "John", role: "admin" }
+ * user.omit("role").value()          // { name: "John", age: 30 }
+ * user.get("name")                   // Some("John")
+ * ```
+ */
+declare const Obj: (<T extends Record<string, Type>>(data: T) => Obj<T>) & {
+  /**
+   * Creates an Obj from a plain object. Alias for Obj().
+   * @param data - The plain object to wrap
+   * @returns A new Obj instance
+   */
+  of: <T extends Record<string, Type>>(data: T) => Obj<T>;
+  /**
+   * Creates an empty Obj.
+   * @returns An empty Obj instance
+   */
+  empty: <T extends Record<string, Type>>() => Obj<T>;
+  /**
+   * Deserializes an Obj from a JSON string.
+   * @param json - The JSON string to parse
+   * @returns A new Obj instance
+   */
+  fromJSON: <T extends Record<string, Type>>(json: string) => Obj<T>;
+  /**
+   * Deserializes an Obj from a base64-encoded binary string.
+   * @param binary - The base64 string to decode
+   * @returns A new Obj instance
+   */
+  fromBinary: <T extends Record<string, Type>>(binary: string) => Obj<T>;
+};
+//#endregion
 //#region src/ref/Ref.d.ts
 /**
  * A mutable reference container that holds a value of type A.
@@ -4745,4 +5036,4 @@ interface FailureErrorType extends Error {
 }
 declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
 //#endregion
-export { TestClockTag as $, TaskFailure as $t, OptionConstructor as A, ValidatedBrand as An, ValidationRule as At, fromBinary as B, ContainerOps as Bn, TaskErrorInfo as Bt, Functype as C, NonEmptyString as Cn, OptionKind as Ct, List as D, PositiveNumber as Dn, FieldValidation as Dt, Collection as E, PositiveInteger as En, FoldableUtils as Et, Set as F, Applicative as Fn, TypedError as Ft, MatchableUtils as G, Doable as Gn, Async as Gt, fromYAML as H, Extractable as Hn, formatError as Ht, SerializationResult as I, AsyncMonad as In, TypedErrorContext as It, Map$1 as J, Err as Jt, ESMap as K, ParseError as Kn, CancellationToken as Kt, createCustomSerializer as L, Functor as Ln, ErrorChainElement as Lt, Stack as M, Try as Mn, ErrorCode as Mt, Valuable as N, TypeNames as Nn, ErrorMessage as Nt, None as O, UUID as On, FormValidation as Ot, ValuableParams as P, Promisable as Pn, ErrorStatus as Pt, TestClock as Q, Task$1 as Qt, createSerializationCompanion as R, Monad as Rn, ErrorFormatterOptions as Rt, tryCatchAsync as S, IntegerNumber as Sn, ListKind as St, FunctypeCollection as T, PatternString as Tn, UniversalContainer as Tt, Ref as U, isExtractable as Un, formatStackTrace as Ut, fromJSON as V, LazyList as Vn, createErrorSerializer as Vt, Matchable as W, DoResult as Wn, safeStringify as Wt, Traversable as X, Sync as Xt, SafeTraversable as Y, Ok as Yt, Lazy as Z, TaggedThrowable as Zt, TypeCheckLeft as _, Companion as _n, TagService as _t, EmptyListError as a, createCancellationTokenSource as an, TimeoutError as at, isRight as b, EmailAddress as bn, HKT as bt, LeftError as c, Throwable as cn, LayerError as ct, isDoCapable as d, Match as dn, Exit as dt, TaskMetadata as en, TestContext as et, unwrap as f, UntypedMatch as fn, ExitTag as ft, TestEither as g, isCompanion as gn, Tag as gt, Right as h, InstanceType as hn, HasService as ht, DoGenerator as i, TaskSuccess as in, Task as it, Some as j, ValidatedBrandCompanion as jn, Validator as jt, Option as k, UrlString as kn, Validation as kt, LeftErrorType as l, ThrowableType as ln, LayerInput as lt, Left as m, CompanionMethods as mn, ContextServices as mt, Do as n, TaskParams as nn, InterruptedError as nt, FailureError as o, isTaggedThrowable as on, UIO as ot, Either as p, Cond as pn, Context as pt, ESMapType as q, CancellationTokenSource as qt, DoAsync as r, TaskResult as rn, RIO as rt, FailureErrorType as s, NAME as sn, Layer as st, $ as t, TaskOutcome as tn, IO as tt, NoneError as u, Base as un, LayerOutput as ut, TypeCheckRight as v, BoundedNumber as vn, Identity as vt, FunctypeBase as w, NonNegativeNumber as wn, TryKind as wt, tryCatch as x, ISO8601Date as xn, Kind as xt, isLeft as y, BoundedString as yn, EitherKind as yt, createSerializer as z, CollectionOps as zn, ErrorWithTaskInfo as zt };
+export { Identity as $, ContainerOps as $n, TaskErrorInfo as $t, OptionConstructor as A, Companion as An, LayerError as At, fromBinary as B, PositiveNumber as Bn, FieldValidation as Bt, Functype as C, Base as Cn, IO as Ct, List as D, CompanionMethods as Dn, TimeoutError as Dt, Collection as E, Cond as En, Task as Et, Set as F, IntegerNumber as Fn, Context as Ft, Matchable as G, Try as Gn, ErrorCode as Gt, fromYAML as H, UrlString as Hn, Validation as Ht, SerializationResult as I, NonEmptyString as In, ContextServices as It, ESMapType as J, Applicative as Jn, TypedError as Jt, MatchableUtils as K, TypeNames as Kn, ErrorMessage as Kt, createCustomSerializer as L, NonNegativeNumber as Ln, HasService as Lt, Stack as M, BoundedString as Mn, LayerOutput as Mt, Valuable as N, EmailAddress as Nn, Exit as Nt, None as O, InstanceType as On, UIO as Ot, ValuableParams as P, ISO8601Date as Pn, ExitTag as Pt, Lazy as Q, CollectionOps as Qn, ErrorWithTaskInfo as Qt, createSerializationCompanion as R, PatternString as Rn, Tag as Rt, tryCatchAsync as S, ThrowableType as Sn, TestContext as St, FunctypeCollection as T, UntypedMatch as Tn, RIO as Tt, Ref as U, ValidatedBrand as Un, ValidationRule as Ut, fromJSON as V, UUID as Vn, FormValidation as Vt, Obj as W, ValidatedBrandCompanion as Wn, Validator as Wt, KVTraversable as X, Functor as Xn, ErrorChainElement as Xt, Map$1 as Y, AsyncMonad as Yn, TypedErrorContext as Yt, Traversable as Z, Monad as Zn, ErrorFormatterOptions as Zt, TypeCheckLeft as _, TaskSuccess as _n, NetworkError as _t, EmptyListError as a, CancellationToken as an, ParseError as ar, TryKind as at, isRight as b, NAME as bn, TestClock as bt, LeftError as c, Ok as cn, Http as ct, isDoCapable as d, Task$1 as dn, HttpResponse as dt, createErrorSerializer as en, LazyList as er, EitherKind as et, unwrap as f, TaskFailure as fn, ParseMode as ft, TestEither as g, TaskResult as gn, HttpStatusError as gt, Right as h, TaskParams as hn, HttpMethod as ht, DoGenerator as i, Async as in, Doable as ir, OptionKind as it, Some as j, BoundedNumber as jn, LayerInput as jt, Option as k, isCompanion as kn, Layer as kt, LeftErrorType as l, Sync as ln, HttpMethodOptions as lt, Left as m, TaskOutcome as mn, HttpError as mt, Do as n, formatStackTrace as nn, isExtractable as nr, Kind as nt, FailureError as o, CancellationTokenSource as on, UniversalContainer as ot, Either as p, TaskMetadata as pn, DecodeError as pt, ESMap as q, Promisable as qn, ErrorStatus as qt, DoAsync as r, safeStringify as rn, DoResult as rr, ListKind as rt, FailureErrorType as s, Err as sn, FoldableUtils as st, $ as t, formatError as tn, Extractable as tr, HKT as tt, NoneError as u, TaggedThrowable as un, HttpRequestOptions as ut, TypeCheckRight as v, createCancellationTokenSource as vn, HttpClient as vt, FunctypeBase as w, Match as wn, InterruptedError as wt, tryCatch as x, Throwable as xn, TestClockTag as xt, isLeft as y, isTaggedThrowable as yn, HttpClientConfig as yt, createSerializer as z, PositiveInteger as zn, TagService as zt };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import { a as ExtractBrand, c as hasBrand, i as BrandedString, l as unwrapBrand, n as BrandedBoolean, o as Unwrap, r as BrandedNumber, s as createBrander, t as Brand } from "./Brand-BJIRbUKB.js";
-import { $ as TestClockTag, $t as TaskFailure, A as OptionConstructor, An as ValidatedBrand, At as ValidationRule, B as fromBinary, Bn as ContainerOps, Bt as TaskErrorInfo, C as Functype, Cn as NonEmptyString, Ct as OptionKind, D as List, Dn as PositiveNumber, Dt as FieldValidation, E as Collection, En as PositiveInteger, Et as FoldableUtils, F as Set, Fn as Applicative, Ft as TypedError, G as MatchableUtils, Gn as Doable, Gt as Async, H as fromYAML, Hn as Extractable, Ht as formatError, I as SerializationResult, In as AsyncMonad, It as TypedErrorContext, J as Map, Jt as Err, K as ESMap, Kn as ParseError, Kt as CancellationToken, L as createCustomSerializer, Ln as Functor, Lt as ErrorChainElement, M as Stack, Mn as Try, Mt as ErrorCode, N as Valuable, Nn as TypeNames, Nt as ErrorMessage, O as None, On as UUID, Ot as FormValidation, P as ValuableParams, Pn as Promisable, Pt as ErrorStatus, Q as TestClock, Qt as Task$1, R as createSerializationCompanion, Rn as Monad, Rt as ErrorFormatterOptions, S as tryCatchAsync, Sn as IntegerNumber, St as ListKind, T as FunctypeCollection, Tn as PatternString, Tt as UniversalContainer, U as Ref, Un as isExtractable, Ut as formatStackTrace, V as fromJSON, Vn as LazyList, Vt as createErrorSerializer, W as Matchable, Wn as DoResult, Wt as safeStringify, X as Traversable, Xt as Sync, Y as SafeTraversable, Yt as Ok, Z as Lazy, Zt as TaggedThrowable, _ as TypeCheckLeft, _n as Companion, _t as TagService, a as EmptyListError, an as createCancellationTokenSource, at as TimeoutError, b as isRight, bn as EmailAddress, bt as HKT, c as LeftError, cn as Throwable, ct as LayerError, d as isDoCapable, dn as Match, dt as Exit, en as TaskMetadata, et as TestContext, f as unwrap, fn as UntypedMatch, ft as ExitTag, g as TestEither, gn as isCompanion, gt as Tag, h as Right, hn as InstanceType, ht as HasService, i as DoGenerator, in as TaskSuccess, it as Task, j as Some, jn as ValidatedBrandCompanion, jt as Validator, k as Option, kn as UrlString, kt as Validation, l as LeftErrorType, ln as ThrowableType, lt as LayerInput, m as Left, mn as CompanionMethods, mt as ContextServices, n as Do, nn as TaskParams, nt as InterruptedError, o as FailureError, on as isTaggedThrowable, ot as UIO, p as Either, pn as Cond, pt as Context, q as ESMapType, qt as CancellationTokenSource, r as DoAsync, rn as TaskResult, rt as RIO, s as FailureErrorType, sn as NAME, st as Layer, t as $, tn as TaskOutcome, tt as IO, u as NoneError, un as Base, ut as LayerOutput, v as TypeCheckRight, vn as BoundedNumber, vt as Identity, w as FunctypeBase, wn as NonNegativeNumber, wt as TryKind, x as tryCatch, xn as ISO8601Date, xt as Kind, y as isLeft, yn as BoundedString, yt as EitherKind, z as createSerializer, zn as CollectionOps, zt as ErrorWithTaskInfo } from "./index-B5zYifBQ.js";
+import { $ as Identity, $n as ContainerOps, $t as TaskErrorInfo, A as OptionConstructor, An as Companion, At as LayerError, B as fromBinary, Bn as PositiveNumber, Bt as FieldValidation, C as Functype, Cn as Base, Ct as IO, D as List, Dn as CompanionMethods, Dt as TimeoutError, E as Collection, En as Cond, Et as Task, F as Set, Fn as IntegerNumber, Ft as Context, G as Matchable, Gn as Try, Gt as ErrorCode, H as fromYAML, Hn as UrlString, Ht as Validation, I as SerializationResult, In as NonEmptyString, It as ContextServices, J as ESMapType, Jn as Applicative, Jt as TypedError, K as MatchableUtils, Kn as TypeNames, Kt as ErrorMessage, L as createCustomSerializer, Ln as NonNegativeNumber, Lt as HasService, M as Stack, Mn as BoundedString, Mt as LayerOutput, N as Valuable, Nn as EmailAddress, Nt as Exit, O as None, On as InstanceType, Ot as UIO, P as ValuableParams, Pn as ISO8601Date, Pt as ExitTag, Q as Lazy, Qn as CollectionOps, Qt as ErrorWithTaskInfo, R as createSerializationCompanion, Rn as PatternString, Rt as Tag, S as tryCatchAsync, Sn as ThrowableType, St as TestContext, T as FunctypeCollection, Tn as UntypedMatch, Tt as RIO, U as Ref, Un as ValidatedBrand, Ut as ValidationRule, V as fromJSON, Vn as UUID, Vt as FormValidation, W as Obj, Wn as ValidatedBrandCompanion, Wt as Validator, X as KVTraversable, Xn as Functor, Xt as ErrorChainElement, Y as Map, Yn as AsyncMonad, Yt as TypedErrorContext, Z as Traversable, Zn as Monad, Zt as ErrorFormatterOptions, _ as TypeCheckLeft, _n as TaskSuccess, _t as NetworkError, a as EmptyListError, an as CancellationToken, ar as ParseError, at as TryKind, b as isRight, bn as NAME, bt as TestClock, c as LeftError, cn as Ok, ct as Http, d as isDoCapable, dn as Task$1, dt as HttpResponse, en as createErrorSerializer, er as LazyList, et as EitherKind, f as unwrap, fn as TaskFailure, ft as ParseMode, g as TestEither, gn as TaskResult, gt as HttpStatusError, h as Right, hn as TaskParams, ht as HttpMethod, i as DoGenerator, in as Async, ir as Doable, it as OptionKind, j as Some, jn as BoundedNumber, jt as LayerInput, k as Option, kn as isCompanion, kt as Layer, l as LeftErrorType, ln as Sync, lt as HttpMethodOptions, m as Left, mn as TaskOutcome, mt as HttpError, n as Do, nn as formatStackTrace, nr as isExtractable, nt as Kind, o as FailureError, on as CancellationTokenSource, ot as UniversalContainer, p as Either, pn as TaskMetadata, pt as DecodeError, q as ESMap, qn as Promisable, qt as ErrorStatus, r as DoAsync, rn as safeStringify, rr as DoResult, rt as ListKind, s as FailureErrorType, sn as Err, st as FoldableUtils, t as $, tn as formatError, tr as Extractable, tt as HKT, u as NoneError, un as TaggedThrowable, ut as HttpRequestOptions, v as TypeCheckRight, vn as createCancellationTokenSource, vt as HttpClient, w as FunctypeBase, wn as Match, wt as InterruptedError, x as tryCatch, xn as Throwable, xt as TestClockTag, y as isLeft, yn as isTaggedThrowable, yt as HttpClientConfig, z as createSerializer, zn as PositiveInteger, zt as TagService } from "./index-Di7IFeuy.js";
 import { a as isTypeable, c as Pipe, i as TypeableParams, l as Foldable, n as ExtractTag, o as Serializable, r as Typeable, s as SerializationMethods, t as Tuple, u as Type } from "./Tuple-DwyoW0ZP.js";
-export { $, Applicative, Async, AsyncMonad, Base, BoundedNumber, BoundedString, Brand, BrandedBoolean, BrandedBoolean as BrandedBooleanType, BrandedNumber, BrandedNumber as BrandedNumberType, BrandedString, BrandedString as BrandedStringType, CancellationToken, CancellationTokenSource, Collection, CollectionOps, Companion, CompanionMethods, Cond, ContainerOps, Context, Context as ContextType, ContextServices, Do, DoAsync, DoGenerator, DoResult, Doable, ESMap, ESMapType, Either, EitherKind, EmailAddress, EmptyListError, Err, ErrorChainElement, ErrorCode, ErrorFormatterOptions, ErrorMessage, ErrorStatus, ErrorWithTaskInfo, Exit, Exit as ExitType, ExitTag, ExtractBrand, ExtractTag, Extractable, FailureError, FailureErrorType, FieldValidation, Foldable, FoldableUtils, FormValidation, Functor, Functype, FunctypeBase, FunctypeCollection, HKT, HasService, IO, IO as IOType, Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, Kind, Layer, Layer as LayerType, LayerError, LayerInput, LayerOutput, Lazy, Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, List, ListKind, Map, Match, Matchable, MatchableUtils, Monad, NAME, NonEmptyString, NonNegativeNumber, None, NoneError, Ok, Option, OptionConstructor, OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, RIO, Ref, Ref as RefType, Right, SafeTraversable, Serializable, SerializationMethods, SerializationResult, Set, Some, Stack, Sync, Tag, Tag as TagType, TagService, TaggedThrowable, Task$1 as Task, TaskErrorInfo, TaskFailure, TaskMetadata, TaskOutcome, TaskParams, TaskResult, TaskSuccess, TestClock, TestClock as TestClockType, TestClockTag, TestContext, TestContext as TestContextType, TestEither, Throwable, ThrowableType, TimeoutError, Traversable, Try, TryKind, Tuple, Type, TypeCheckLeft, TypeCheckRight, TypeNames, Typeable, TypeableParams, TypedError, TypedErrorContext, UIO, UUID, UniversalContainer, UntypedMatch, Unwrap, UrlString, ValidatedBrand, ValidatedBrand as ValidatedBrandType, ValidatedBrandCompanion, Validation, ValidationRule, Validator, Valuable, ValuableParams, createBrander, createCancellationTokenSource, createCustomSerializer, createErrorSerializer, createSerializationCompanion, createSerializer, formatError, formatStackTrace, fromBinary, fromJSON, fromYAML, hasBrand, isCompanion, isDoCapable, isExtractable, isLeft, isRight, isTaggedThrowable, isTypeable, safeStringify, tryCatch, tryCatchAsync, unwrap, unwrapBrand };
+export { $, Applicative, Async, AsyncMonad, Base, BoundedNumber, BoundedString, Brand, BrandedBoolean, BrandedBoolean as BrandedBooleanType, BrandedNumber, BrandedNumber as BrandedNumberType, BrandedString, BrandedString as BrandedStringType, CancellationToken, CancellationTokenSource, Collection, CollectionOps, Companion, CompanionMethods, Cond, ContainerOps, Context, Context as ContextType, ContextServices, DecodeError, Do, DoAsync, DoGenerator, DoResult, Doable, ESMap, ESMapType, Either, EitherKind, EmailAddress, EmptyListError, Err, ErrorChainElement, ErrorCode, ErrorFormatterOptions, ErrorMessage, ErrorStatus, ErrorWithTaskInfo, Exit, Exit as ExitType, ExitTag, ExtractBrand, ExtractTag, Extractable, FailureError, FailureErrorType, FieldValidation, Foldable, FoldableUtils, FormValidation, Functor, Functype, FunctypeBase, FunctypeCollection, HKT, HasService, Http, HttpClient, HttpClientConfig, HttpError, HttpError as HttpErrors, HttpMethod, HttpMethodOptions, HttpRequestOptions, HttpResponse, HttpStatusError, IO, IO as IOType, Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, KVTraversable, Kind, Layer, Layer as LayerType, LayerError, LayerInput, LayerOutput, Lazy, Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, List, ListKind, Map, Match, Matchable, MatchableUtils, Monad, NAME, NetworkError, NonEmptyString, NonNegativeNumber, None, NoneError, Obj, Ok, Option, OptionConstructor, OptionKind, ParseError, ParseMode, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, RIO, Ref, Ref as RefType, Right, Serializable, SerializationMethods, SerializationResult, Set, Some, Stack, Sync, Tag, Tag as TagType, TagService, TaggedThrowable, Task$1 as Task, TaskErrorInfo, TaskFailure, TaskMetadata, TaskOutcome, TaskParams, TaskResult, TaskSuccess, TestClock, TestClock as TestClockType, TestClockTag, TestContext, TestContext as TestContextType, TestEither, Throwable, ThrowableType, TimeoutError, Traversable, Try, TryKind, Tuple, Type, TypeCheckLeft, TypeCheckRight, TypeNames, Typeable, TypeableParams, TypedError, TypedErrorContext, UIO, UUID, UniversalContainer, UntypedMatch, Unwrap, UrlString, ValidatedBrand, ValidatedBrand as ValidatedBrandType, ValidatedBrandCompanion, Validation, ValidationRule, Validator, Valuable, ValuableParams, createBrander, createCancellationTokenSource, createCustomSerializer, createErrorSerializer, createSerializationCompanion, createSerializer, formatError, formatStackTrace, fromBinary, fromJSON, fromYAML, hasBrand, isCompanion, isDoCapable, isExtractable, isLeft, isRight, isTaggedThrowable, isTypeable, safeStringify, tryCatch, tryCatchAsync, unwrap, unwrapBrand };