@duplojs/utils 1.3.32 → 1.4.33

package/dist/object/discriminate.d.ts

@@ -1,4 +1,57 @@
 import { type EligibleEqual, type MaybeArray } from "../common";
+/**
+ * Checks a property value and narrows the object type.
+ * 
+ * **Supported call styles:**
+ * - Classic: `discriminate(input, key, value)` → returns a boolean
+ * - Curried: `discriminate(key, value)` → returns a function waiting for the input
+ * - Classic predicate: `discriminate(input, key, value)` → narrows the object type
+ * - Curried predicate: `discriminate(key, value)` → narrows the object type
+ * 
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * const shapeObj = {
+ * 	kind: "circle",
+ * 	radius: 2,
+ * } as {
+ * 	kind: "circle";
+ * 	radius: number;
+ * } | {
+ * 	kind: "square";
+ * 	size: number;
+ * };
+ * 
+ * if (O.discriminate(shapeObj, "kind", "circle")) {
+ * 	// shapeObj is circle
+ * }
+ * 
+ * pipe(
+ * 	shapeObj,
+ * 	when(
+ * 		O.discriminate("kind", "square"),
+ * 		(value) => {
+ * 			// value is square
+ * 		},
+ * 	),
+ * );
+ * 
+ * O.discriminate(
+ * 	{
+ * 		status: "ready",
+ * 	},
+ * ```
+ * 
+ * @remarks
+ * - Predicate overloads (type guards) narrow the output type
+ * - The discriminated value can be an array, acting as an "or" list
+ * 
+ * @see [`O.deepDiscriminate`](https://utils.duplojs.dev/en/v1/api/object/deepDiscriminate) For deep paths
+ * @see https://utils.duplojs.dev/en/v1/api/object/discriminate
+ * 
+ * @namespace O
+ * 
+ */
 export declare function discriminate<GenericInput extends object, GenericKey extends keyof GenericInput, GenericValue extends EligibleEqual>(key: GenericKey, value: (MaybeArray<(GenericValue & Extract<GenericInput[GenericKey], EligibleEqual>)> | MaybeArray<Extract<GenericInput[GenericKey], EligibleEqual>>)): (input: GenericInput) => input is Extract<GenericInput, {
     [Prop in GenericKey]: GenericValue;
 }>;

package/dist/object/entries.cjs

@@ -3,6 +3,9 @@
 var wrapValue = require('../common/wrapValue.cjs');
 var kind = require('../common/kind.cjs');
 
+/**
+ * {@include object/entries/index.md}
+ */
 function entries(object) {
     return Object.entries(object)
         .filter(([key]) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key));

package/dist/object/entries.d.ts

@@ -5,6 +5,37 @@ export type GetEntry<GenericKey extends ObjectKey, GenericValue extends unknown>
 export type GetEntries<GenericObject extends object> = GenericObject extends readonly any[] ? [DString.Number, GenericObject[number]][] : IsEqual<GenericObject, object> extends true ? [string, AnyValue][] : ({
     [Prop in keyof GenericObject]-?: GetEntry<Prop, GenericObject[Prop]>;
 }[keyof GenericObject]) extends infer InferredResult extends ObjectEntry ? IsEqual<InferredResult, never> extends true ? [] : InferredResult[] : never;
+/**
+ * Returns object entries as key-value pairs.
+ * 
+ * Signature: `entries(object)` → returns entries
+ * 
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * O.entries(
+ * 	{
+ * 		name: "Ada",
+ * 		age: 36,
+ * 	},
+ * ); // [["name", "Ada"], ["age", 36]]
+ * 
+ * O.entries(
+ * 	{
+ * 		active: true,
+ * 	},
+ * ); // [["active", true]]
+ * ```
+ * 
+ * @remarks
+ * - Filters runtime keys used by the library
+ * - Uses the same semantics as [`Object.entries`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/object/entries
+ * 
+ * @namespace O
+ * 
+ */
 export declare function entries<GenericObject extends object>(object: GenericObject): SimplifyTopLevel<GetEntries<GenericObject>>;
 export declare namespace entries {
     var unsafe: <GenericObject extends object>(object: GenericObject) => [string, AnyValue][];

package/dist/object/entries.mjs

@@ -1,6 +1,9 @@
 import { isRuntimeWrappedValueKey } from '../common/wrapValue.mjs';
 import { isRuntimeKind } from '../common/kind.mjs';
 
+/**
+ * {@include object/entries/index.md}
+ */
 function entries(object) {
     return Object.entries(object)
         .filter(([key]) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key));

package/dist/object/entry.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include object/entry/index.md}
+ */
 function entry(key, value) {
     return [key, value];
 }

package/dist/object/entry.d.ts

@@ -1,2 +1,31 @@
 import { type ObjectKey } from "../common";
+/**
+ * Creates an entry tuple from a key and value.
+ * 
+ * Signature: `entry(key, value)` → returns a tuple
+ * 
+ * ```ts
+ * O.entry(
+ * 	"name",
+ * 	"Ada",
+ * ); // ["name", "Ada"]
+ * 
+ * O.entry(
+ * 	"active",
+ * 	true,
+ * ); // ["active", true]
+ * 
+ * O.entry(
+ * 	"count",
+ * 	2,
+ * ); // ["count", 2]
+ * 
+ * ```
+ * 
+ * @see [`O.fromEntries`](https://utils.duplojs.dev/en/v1/api/object/fromEntries) For building objects
+ * @see https://utils.duplojs.dev/en/v1/api/object/entry
+ * 
+ * @namespace O
+ * 
+ */
 export declare function entry<GenericKey extends ObjectKey, GenericValue extends unknown>(key: GenericKey, value: GenericValue): readonly [GenericKey, GenericValue];

package/dist/object/entry.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include object/entry/index.md}
+ */
 function entry(key, value) {
     return [key, value];
 }

package/dist/object/fromEntries.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include object/fromEntries/index.md}
+ */
 function fromEntries(entries) {
     return Object.fromEntries(entries);
 }

package/dist/object/fromEntries.d.ts

@@ -4,5 +4,44 @@ type ComputeEntries<GenericEntry extends ObjectEntry> = UnionContain<ObjectKey,
 }> : SimplifyTopLevel<{
     [Entry in GenericEntry as Entry[0]]?: Entry[1];
 }>;
+/**
+ * Creates an object from entries.
+ * 
+ * Signature: `fromEntries(entries)` → returns an object
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * O.fromEntries(
+ * 	[
+ * 		[
+ * 			"name",
+ * 			"Ada",
+ * 		],
+ * 		[
+ * 			"age",
+ * 			36,
+ * 		],
+ * 	],
+ * ); // { name: "Ada", age: 36 }
+ * 
+ * O.fromEntries(
+ * 	[
+ * 		[
+ * 			"active",
+ * 			true,
+ * 		],
+ * 	],
+ * ); // { active: true }
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Object.fromEntries`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/object/fromEntries
+ * 
+ * @namespace O
+ * 
+ */
 export declare function fromEntries<GenericKey extends ObjectKey, const GenericEntry extends readonly [GenericKey, unknown]>(entries: readonly GenericEntry[]): ComputeEntries<GenericEntry>;
 export {};

package/dist/object/fromEntries.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include object/fromEntries/index.md}
+ */
 function fromEntries(entries) {
     return Object.fromEntries(entries);
 }

package/dist/object/getDeepProperty.d.ts

@@ -1,6 +1,52 @@
 import { type EligibleEqual } from "../common";
 import { type FlatObject, type GetPropsWithValueExtends } from "./types";
 type ObjectProjection<GenericInput extends object> = FlatObject<GenericInput> extends infer InferredResult extends object ? Omit<Pick<InferredResult, GetPropsWithValueExtends<InferredResult, EligibleEqual>>, `${string}[${string}]${string}`> : never;
+/**
+ * Gets a nested property value using a path.
+ * 
+ * **Supported call styles:**
+ * - Classic: `getDeepProperty(input, path)` → returns the value
+ * - Curried: `getDeepProperty(path)` → returns a function waiting for the input
+ * 
+ * The path uses dot notation.
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * O.getDeepProperty(
+ * 	{
+ * 		user: {
+ * 			name: "Ada",
+ * 		},
+ * 	},
+ * 	"user.name",
+ * ); // "Ada"
+ * 
+ * pipe(
+ * 	{
+ * 		meta: {
+ * 			count: 2,
+ * 		},
+ * 	},
+ * 	O.getDeepProperty("meta.count"),
+ * ); // 2
+ * 
+ * O.getDeepProperty(
+ * 	{
+ * 		settings: {
+ * 			theme: "light",
+ * 		},
+ * 	},
+ * 	"settings.theme",
+ * ); // "light"
+ * 
+ * ```
+ * 
+ * @see [`O.getProperty`](https://utils.duplojs.dev/en/v1/api/object/getProperty) For top-level keys
+ * @see https://utils.duplojs.dev/en/v1/api/object/getDeepProperty
+ * 
+ * @namespace O
+ * 
+ */
 export declare function getDeepProperty<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection>(path: GenericPath): (input: GenericInput) => GenericObjectProjection[GenericPath];
 export declare function getDeepProperty<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection>(input: GenericInput, path: GenericPath): GenericObjectProjection[GenericPath];
 export {};

package/dist/object/getProperty.d.ts

@@ -3,6 +3,45 @@ import { type UnionObjectToIntersection } from "./types/UnionObjectToIntersectio
 type MergeTopLevelUnionObject<GenericObject extends object, GenericFullObjectKeys extends keyof UnionObjectToIntersection<GenericObject> = keyof UnionObjectToIntersection<GenericObject>> = PartialKeys<{
     [Prop in GenericFullObjectKeys]: (GenericObject extends object ? Prop extends keyof GenericObject ? GenericObject[Prop] : never : never);
 }, Exclude<GenericFullObjectKeys, keyof GenericObject>>;
+/**
+ * Gets a property value by key.
+ * 
+ * **Supported call styles:**
+ * - Classic: `getProperty(obj, key)` → returns the value
+ * - Curried: `getProperty(key)` → returns a function waiting for the object
+ * 
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * O.getProperty(
+ * 	{
+ * 		name: "Ada",
+ * 	},
+ * 	"name",
+ * ); // "Ada"
+ * 
+ * pipe(
+ * 	{
+ * 		count: 2,
+ * 	},
+ * 	O.getProperty("count"),
+ * ); // 2
+ * 
+ * O.getProperty(
+ * 	{
+ * 		active: true,
+ * 	},
+ * 	"active",
+ * ); // true
+ * 
+ * ```
+ * 
+ * @see [`O.getDeepProperty`](https://utils.duplojs.dev/en/v1/api/object/getDeepProperty) For nested paths
+ * @see https://utils.duplojs.dev/en/v1/api/object/getProperty
+ * 
+ * @namespace O
+ * 
+ */
 export declare function getProperty<GenericObject extends object, GenericFullObject extends MergeTopLevelUnionObject<GenericObject>, GenericKey extends keyof GenericFullObject>(key: GenericKey): (obj: GenericObject) => GenericFullObject[GenericKey];
 export declare function getProperty<GenericObject extends object, GenericFullObject extends MergeTopLevelUnionObject<GenericObject>, GenericKey extends keyof GenericFullObject>(obj: GenericObject, key: GenericKey): GenericFullObject[GenericKey];
 export {};

package/dist/object/hasKeys.d.ts

@@ -1,3 +1,51 @@
 import { type RequiredKeys } from "./types/requiredKeys";
+/**
+ * Checks if an object has specific keys defined.
+ * 
+ * **Supported call styles:**
+ * - Classic: `hasKeys(partialObject, keys)` → returns a boolean
+ * - Curried: `hasKeys(keys)` → returns a function waiting for the object
+ * - Classic predicate: `hasKeys(partialObject, keys)` → narrows the object type
+ * - Curried predicate: `hasKeys(keys)` → narrows the object type
+ * 
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * const partialObj: {
+ * 	name?: string;
+ * 	age?: number;
+ * } = {
+ * 	name: "Ada",
+ * };
+ * 
+ * if (O.hasKeys(partialObj, "name")) {
+ * 	// partialObj has key "name"
+ * }
+ * 
+ * pipe(
+ * 	partialObj,
+ * 	when(
+ * 		O.hasKeys(
+ * 			[
+ * 				"name",
+ * 				"age",
+ * 			], // and
+ * 		),
+ * 		(value) => {
+ * 			// value has both keys
+ * 		},
+ * 	),
+ * );
+ * ```
+ * 
+ * @remarks
+ * - Predicate overloads (type guards) narrow the object type
+ * - Passing an array of keys acts as an "and" (all keys must be present)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/object/hasKeys
+ * 
+ * @namespace O
+ * 
+ */
 export declare function hasKeys<GenericObject extends object, GenericKeys extends keyof GenericObject>(keys: GenericKeys | readonly GenericKeys[]): (partialObject: GenericObject) => partialObject is RequiredKeys<GenericObject, NoInfer<GenericKeys>>;
 export declare function hasKeys<GenericObject extends object, GenericKeys extends keyof GenericObject>(partialObject: GenericObject, keys: GenericKeys | readonly GenericKeys[]): partialObject is RequiredKeys<GenericObject, NoInfer<GenericKeys>>;

package/dist/object/index.cjs

@@ -19,7 +19,9 @@ var getDeepProperty = require('./getDeepProperty.cjs');
 var discriminate = require('./discriminate.cjs');
 var entry = require('./entry.cjs');
 
-
+/**
+ * {@include object/index.md}
+ */
 
 exports.entries = entries.entries;
 exports.fromEntries = fromEntries.fromEntries;

package/dist/object/index.d.ts

@@ -1,3 +1,28 @@
+/**
+ * Object utilities for immutable, type-safe object manipulation. Functions preserve the
+ * original object and return new values.
+ * 
+ * **How to import:**
+ * - From the main entry (namespace style)
+ * - Via direct import for tree-shaking
+ * 
+ * ```ts
+ * import { DObject, O } from "@duplojs/utils";
+ * import * as DObject from "@duplojs/utils/object";
+ * import * as O from "@duplojs/utils/object";
+ * ```
+ * 
+ * What you will find in this namespace:
+ * - access and queries (`O.getProperty`, `O.getDeepProperty`, `O.hasKeys`)
+ * - transforms (`O.transformProperty`, `O.transformProperties`, `O.to`)
+ * - composition (`O.assign`, `O.override`, `O.pick`, `O.omit`)
+ * - entries and keys (`O.entries`, `O.fromEntries`, `O.keys`, `O.values`)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/object
+ * 
+ * @namespace O
+ * 
+ */
 export * from "./types";
 export * from "./entries";
 export * from "./fromEntries";

package/dist/object/index.mjs

@@ -16,3 +16,7 @@ export { deepDiscriminate } from './deepDiscriminate.mjs';
 export { getDeepProperty } from './getDeepProperty.mjs';
 export { discriminate } from './discriminate.mjs';
 export { entry } from './entry.mjs';
+
+/**
+ * {@include object/index.md}
+ */

package/dist/object/keys.cjs

@@ -3,6 +3,9 @@
 var wrapValue = require('../common/wrapValue.cjs');
 var kind = require('../common/kind.cjs');
 
+/**
+ * {@include object/keys/index.md}
+ */
 function keys(object) {
     return Object.keys(object)
         .filter((key) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key));

package/dist/object/keys.d.ts

@@ -1 +1,34 @@
+/**
+ * Returns object keys.
+ * 
+ * Signature: `keys(object)` → returns keys
+ * 
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * O.keys(
+ * 	{
+ * 		name: "Ada",
+ * 		age: 36,
+ * 	},
+ * ); // ["name", "age"]
+ * 
+ * pipe(
+ * 	{
+ * 		name: "William",
+ * 		role: "client",
+ * 	},
+ * 	O.keys,
+ * ); // ["name", "role"]
+ * ```
+ * 
+ * @remarks
+ * - Filters runtime keys used by the library
+ * - Uses the same semantics as [`Object.keys`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/object/keys
+ * 
+ * @namespace O
+ * 
+ */
 export declare function keys<GenericObject extends object>(object: GenericObject): (Exclude<keyof GenericObject, symbol>)[];

package/dist/object/keys.mjs

@@ -1,6 +1,9 @@
 import { isRuntimeWrappedValueKey } from '../common/wrapValue.mjs';
 import { isRuntimeKind } from '../common/kind.mjs';
 
+/**
+ * {@include object/keys/index.md}
+ */
 function keys(object) {
     return Object.keys(object)
         .filter((key) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key));

package/dist/object/omit.d.ts

@@ -3,6 +3,52 @@ import { type Adaptor } from "../common/types/adaptor";
 import { type GetPropsWithValue } from "./types/getPropsWithValue";
 import { type PartialKeys } from "./types";
 type ComputeResultWithOmitIsObject<GenericInput extends object, GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>>> = SimplifyTopLevel<Omit<GenericInput, GetPropsWithValue<GenericOmitValue, true>> extends infer InferredValue extends object ? PartialKeys<InferredValue, Adaptor<GetPropsWithValue<GenericOmitValue, boolean> | GetPropsWithValue<GenericOmitValue, boolean | undefined> | GetPropsWithValue<GenericOmitValue, true | undefined>, keyof InferredValue>> : never>;
+/**
+ * Removes properties from an object.
+ * 
+ * **Supported call styles:**
+ * - Classic: `omit(input, omitValue)` → returns a new object
+ * - Curried: `omit(omitValue)` → returns a function waiting for the input
+ * 
+ * The `omitValue` can be a key array or a map of keys to booleans.
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * O.omit(
+ * 	{
+ * 		name: "Ada",
+ * 		age: 36,
+ * 	},
+ * 	["age"],
+ * ); // { name: "Ada" }
+ * 
+ * O.omit(
+ * 	{
+ * 		name: "Ada",
+ * 		age: 36,
+ * 		active: true,
+ * 	},
+ * 	{
+ * 		active: true,
+ * 	},
+ * ); // { name: "Ada", age: 36 }
+ * 
+ * pipe(
+ * 	{
+ * 		role: "admin",
+ * 		level: 3,
+ * 	},
+ * 	O.omit(["level"]),
+ * ); // { role: "admin" }
+ * 
+ * ```
+ * 
+ * @see [`O.pick`](https://utils.duplojs.dev/en/v1/api/object/pick) For selecting keys
+ * @see https://utils.duplojs.dev/en/v1/api/object/omit
+ * 
+ * @namespace O
+ * 
+ */
 export declare function omit<GenericInput extends object, const GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>> | readonly (keyof GenericInput)[]>(omitValue: GenericOmitValue): (input: GenericInput) => GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithOmitIsObject<GenericInput, GenericOmitValue> : SimplifyTopLevel<Omit<GenericInput, Adaptor<GenericOmitValue, readonly ObjectKey[]>[number]>>;
 export declare function omit<GenericInput extends object, const GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>> | readonly (keyof GenericInput)[]>(input: GenericInput, omitValue: GenericOmitValue): GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithOmitIsObject<GenericInput, GenericOmitValue> : SimplifyTopLevel<Omit<GenericInput, Adaptor<GenericOmitValue, readonly ObjectKey[]>[number]>>;
 export {};

package/dist/object/override.d.ts

@@ -1,2 +1,51 @@
+/**
+ * Overrides object properties, ignoring undefined values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `override(input, value)` → returns a new object
+ * - Curried: `override(value)` → returns a function waiting for the input
+ * 
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * O.override(
+ * 	{
+ * 		name: "Ada",
+ * 		age: 36,
+ * 	},
+ * 	{
+ * 		age: undefined,
+ * 	},
+ * ); // { name: "Ada", age: 36 }
+ * 
+ * pipe(
+ * 	{
+ * 		count: 1,
+ * 	},
+ * 	O.override({
+ * 		count: 2,
+ * 	}),
+ * ); // { count: 2 }
+ * 
+ * O.override(
+ * 	{
+ * 		active: true,
+ * 	},
+ * 	{
+ * 		active: false,
+ * 	},
+ * ); // { active: false }
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Properties with `undefined` are not applied
+ * 
+ * @see [`O.assign`](https://utils.duplojs.dev/en/v1/api/object/assign) For direct assignment
+ * @see https://utils.duplojs.dev/en/v1/api/object/override
+ * 
+ * @namespace O
+ * 
+ */
 export declare function override<GenericInput extends object>(value: Partial<NoInfer<GenericInput>>): (input: GenericInput) => GenericInput;
 export declare function override<GenericInput extends object>(input: GenericInput, value: Partial<NoInfer<GenericInput>>): GenericInput;

package/dist/object/pick.d.ts

@@ -2,6 +2,53 @@ import { type ObjectKey, type SimplifyTopLevel } from "../common";
 import { type Adaptor } from "../common/types/adaptor";
 import { type GetPropsWithValue } from "./types/getPropsWithValue";
 type ComputeResultWithPickIsObject<GenericInput extends object, GenericPickValue extends Partial<Record<keyof GenericInput, boolean>>> = SimplifyTopLevel<Pick<GenericInput, Adaptor<GetPropsWithValue<GenericPickValue, true>, keyof GenericInput>> & Partial<Pick<GenericInput, Adaptor<GetPropsWithValue<GenericPickValue, boolean> | GetPropsWithValue<GenericPickValue, boolean | undefined> | GetPropsWithValue<GenericPickValue, true | undefined>, keyof GenericInput>>>>;
+/**
+ * Selects properties from an object.
+ * 
+ * **Supported call styles:**
+ * - Classic: `pick(input, pickValue)` → returns a new object
+ * - Curried: `pick(pickValue)` → returns a function waiting for the input
+ * 
+ * The `pickValue` can be a key array or a map of keys to booleans.
+ * The input object is not mutated.
+ * 
+ * ```ts
+ * O.pick(
+ * 	{
+ * 		name: "Ada",
+ * 		age: 36,
+ * 	},
+ * 	["name"],
+ * ); // { name: "Ada" }
+ * 
+ * O.pick(
+ * 	{
+ * 		name: "Ada",
+ * 		age: 36,
+ * 		active: true,
+ * 	},
+ * 	{
+ * 		name: true,
+ * 		active: true,
+ * 	},
+ * ); // { name: "Ada", active: true }
+ * 
+ * pipe(
+ * 	{
+ * 		role: "admin",
+ * 		level: 3,
+ * 	},
+ * 	O.pick(["role"]),
+ * ); // { role: "admin" }
+ * 
+ * ```
+ * 
+ * @see [`O.omit`](https://utils.duplojs.dev/en/v1/api/object/omit) For removing keys
+ * @see https://utils.duplojs.dev/en/v1/api/object/pick
+ * 
+ * @namespace O
+ * 
+ */
 export declare function pick<GenericInput extends object, const GenericPickValue extends Partial<Record<keyof GenericInput, boolean>> | readonly (keyof GenericInput)[]>(pickValue: GenericPickValue): (input: GenericInput) => GenericPickValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithPickIsObject<GenericInput, GenericPickValue> : SimplifyTopLevel<Pick<GenericInput, Adaptor<GenericPickValue, readonly ObjectKey[]>[number]>>;
 export declare function pick<GenericInput extends object, const GenericPickValue extends Partial<Record<keyof GenericInput, boolean>> | readonly (keyof GenericInput)[]>(input: GenericInput, pickValue: GenericPickValue): GenericPickValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithPickIsObject<GenericInput, GenericPickValue> : SimplifyTopLevel<Pick<GenericInput, Adaptor<GenericPickValue, readonly ObjectKey[]>[number]>>;
 export {};