@duplojs/utils 1.3.20 → 1.3.22

package/README.md

@@ -1,2 +1,22 @@
 # @duplojs/utils
-[![NPM version](https://img.shields.io/npm/v/@duplojs/utils)](https://www.npmjs.com/package/@duplojs/utils)
+[![NPM version](https://img.shields.io/npm/v/@duplojs/utils)](https://www.npmjs.com/package/@duplojs/utils)
+
+`@duplojs/utils` is the TypeScript utility toolbox used across the DuploJS ecosystem. It focuses on **strong typing**, **god DX**, and **small composable primitives** that scale from simple helpers to full validation pipelines.
+
+## What’s inside?
+
+- **Common functional utilities**: `pipe`/`asyncPipe`, `when`, `memo`, `clone`, `escapeRegExp`, etc.
+- **Typed runtime tagging**: `kind` helpers to discriminate data without polluting public shapes.
+- **Either**: a typed success/error container with mandatory “information” for precise pattern matching.
+- **DataParser**: schema-based validation with checkers, coercion (`DP.coerce.*`), transforms, async support, and a fluent “extended” API (`DPE`).
+- **Clean-domain building blocks**: `newType`, `entity`, constraints, repositories, and use-cases.
+- **Pure helpers by domain**: `array`, `object`, `string`, `number`, `date`, `generator`, `pattern` (match/exhaustive).
+
+## Documentation
+- https://utils.duplojs.dev/v1/en
+
+## Install
+
+```bash
+npm install @duplojs/utils
+```

package/dist/array/index.cjs

@@ -42,6 +42,7 @@ var notIncludes = require('./notIncludes.cjs');
 var chunk = require('./chunk.cjs');
 var insert$2 = require('./insert.cjs');
 var isLastIndex = require('./isLastIndex.cjs');
+var select = require('./select.cjs');
 var _delete = require('./splice/delete.cjs');
 var insert = require('./splice/insert.cjs');
 var replace = require('./splice/replace.cjs');
@@ -101,6 +102,8 @@ exports.notIncludes = notIncludes.notIncludes;
 exports.chunk = chunk.chunk;
 exports.insert = insert$2.insert;
 exports.isLastIndex = isLastIndex.isLastIndex;
+exports.select = select.select;
+exports.selectTools = select.selectTools;
 exports.spliceDelete = _delete.spliceDelete;
 exports.spliceInsert = insert.spliceInsert;
 exports.spliceReplace = replace.spliceReplace;

package/dist/array/index.d.ts

@@ -45,3 +45,4 @@ export * from "./notIncludes";
 export * from "./chunk";
 export * from "./insert";
 export * from "./isLastIndex";
+export * from "./select";

package/dist/array/index.mjs

@@ -40,6 +40,7 @@ export { notIncludes } from './notIncludes.mjs';
 export { chunk } from './chunk.mjs';
 export { insert } from './insert.mjs';
 export { isLastIndex } from './isLastIndex.mjs';
+export { select, selectTools } from './select.mjs';
 export { spliceDelete } from './splice/delete.mjs';
 export { spliceInsert } from './splice/insert.mjs';
 export { spliceReplace } from './splice/replace.mjs';

package/dist/array/select.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+const selectTools = {
+    skip() {
+        return { "-skip": null };
+    },
+    select(output) {
+        return { "-select": output };
+    },
+};
+function select(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => select(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    const outputArray = [];
+    for (let index = 0; index < input.length; index++) {
+        const element = input[index];
+        const result = theFunction({
+            element,
+            index,
+            self: input,
+            ...selectTools,
+        });
+        if ("-skip" in result) {
+            continue;
+        }
+        outputArray.push(result["-select"]);
+    }
+    return outputArray;
+}
+
+exports.select = select;
+exports.selectTools = selectTools;

package/dist/array/select.d.ts

@@ -0,0 +1,18 @@
+import { type AnyValue } from "../common";
+export interface ArraySelectSelect<GenericOutput extends unknown = unknown> {
+    "-select": GenericOutput;
+}
+export interface ArraySelectSkip {
+    "-skip": null;
+}
+interface ArraySelectParams<GenericInputArray extends readonly unknown[]> {
+    element: GenericInputArray[number];
+    index: number;
+    self: GenericInputArray;
+    skip(): ArraySelectSkip;
+    select<GenericOutput extends AnyValue = AnyValue>(output: GenericOutput): ArraySelectSelect<GenericOutput>;
+}
+export declare const selectTools: Pick<ArraySelectParams<any>, "skip" | "select">;
+export declare function select<GenericInput extends readonly unknown[], GenericSelect extends ArraySelectSelect>(theFunction: (params: ArraySelectParams<GenericInput>) => GenericSelect | ArraySelectSkip): (input: GenericInput) => GenericSelect["-select"][];
+export declare function select<GenericInput extends readonly unknown[], GenericSelect extends ArraySelectSelect>(input: GenericInput, theFunction: (params: ArraySelectParams<GenericInput>) => GenericSelect | ArraySelectSkip): GenericSelect["-select"][];
+export {};

package/dist/array/select.mjs

@@ -0,0 +1,32 @@
+const selectTools = {
+    skip() {
+        return { "-skip": null };
+    },
+    select(output) {
+        return { "-select": output };
+    },
+};
+function select(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => select(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    const outputArray = [];
+    for (let index = 0; index < input.length; index++) {
+        const element = input[index];
+        const result = theFunction({
+            element,
+            index,
+            self: input,
+            ...selectTools,
+        });
+        if ("-skip" in result) {
+            continue;
+        }
+        outputArray.push(result["-select"]);
+    }
+    return outputArray;
+}
+
+export { select, selectTools };

package/dist/clean/constraint/base.d.ts

@@ -32,5 +32,5 @@ export declare function createConstraint<GenericName extends string, GenericPrim
     DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>,
     ...DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]
 ]) = never>(name: GenericName, primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>, checker: GenericChecker): ConstraintHandler<GenericName, GenericPrimitiveValue, DArray.ArrayCoalescing<GenericChecker>>;
-export type Constraint<GenericConstrainHandler extends ConstraintHandler, GenericValue extends DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]> = DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]>> = Extract<ConstrainedType<GenericConstrainHandler["name"], GenericValue>, any>;
+export type GetConstraint<GenericConstrainHandler extends ConstraintHandler, GenericValue extends DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]> = DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]>> = Extract<ConstrainedType<GenericConstrainHandler["name"], GenericValue>, any>;
 export {};

package/dist/clean/constraint/defaultConstraint/number.d.ts

@@ -1,8 +1,8 @@
-import { type Constraint } from "../base";
+import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
 export declare const Int: import("..").ConstraintHandler<"int", number, readonly [DDataParser.DataParserCheckerInt]>;
-export type Int = Constraint<typeof Int>;
+export type Int = GetConstraint<typeof Int>;
 export declare const Positive: import("..").ConstraintHandler<"positive", number, readonly [DDataParser.DataParserCheckerNumberMin]>;
-export type Positive = Constraint<typeof Positive>;
+export type Positive = GetConstraint<typeof Positive>;
 export declare const Negative: import("..").ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax]>;
-export type Negative = Constraint<typeof Negative>;
+export type Negative = GetConstraint<typeof Negative>;

package/dist/clean/constraint/defaultConstraint/string.d.ts

@@ -1,6 +1,6 @@
-import { type Constraint } from "../base";
+import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
 export declare const Email: import("..").ConstraintHandler<"email", string, readonly [DDataParser.DataParserCheckerEmail]>;
-export type Email = Constraint<typeof Email>;
+export type Email = GetConstraint<typeof Email>;
 export declare const Url: import("..").ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl]>;
-export type Url = Constraint<typeof Url>;
+export type Url = GetConstraint<typeof Url>;

package/dist/clean/entity.cjs

@@ -110,6 +110,9 @@ function createEntity(name, getPropertiesDefinition) {
         }
         return unwrap.unwrap(result);
     }
+    function is$1(input) {
+        return entityKind.has(input) && entityKind.getValue(input) === name;
+    }
     return entityHandlerKind.setTo({
         name,
         propertiesDefinition,
@@ -117,6 +120,7 @@ function createEntity(name, getPropertiesDefinition) {
         new: theNew,
         map: map$1,
         mapOrThrow,
+        is: is$1,
     });
 }
 

package/dist/clean/entity.d.ts

@@ -43,6 +43,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
     "new"<GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
     map(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): (DEither.EitherRight<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.EitherLeft<"createEntityError", DDataParser.DataParserError>);
     mapOrThrow(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
+    is<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Entity<GenericName>>;
 }
 declare const CreateEntityError_base: new (params: {
     "@DuplojsUtilsError/create-entity-error"?: unknown;

package/dist/clean/entity.mjs

@@ -108,6 +108,9 @@ function createEntity(name, getPropertiesDefinition) {
         }
         return unwrap(result);
     }
+    function is(input) {
+        return entityKind.has(input) && entityKind.getValue(input) === name;
+    }
     return entityHandlerKind.setTo({
         name,
         propertiesDefinition,
@@ -115,6 +118,7 @@ function createEntity(name, getPropertiesDefinition) {
         new: theNew,
         map: map$1,
         mapOrThrow,
+        is,
     });
 }
 

package/dist/clean/flag.d.ts

@@ -13,4 +13,5 @@ export declare function createFlag<GenericEntity extends Entity = never, Generic
     IsEqual<GenericEntity, never>,
     IsEqual<GenericName, never>
 ]> extends true ? never : NoInfer<GenericName>): FlagHandler<GenericEntity, GenericName, GenericValue>;
+export type GetFlag<GenericHandler extends FlagHandler<any, any, any>> = Extract<Flag<GenericHandler["name"], ReturnType<GenericHandler["getValue"]>>, any>;
 export {};

package/dist/clean/repository.d.ts

@@ -1,8 +1,8 @@
-import { type AnyFunction, type Kind } from "../common";
+import { type SimplifyTopLevel, type AnyFunction, type Kind } from "../common";
 export declare const repositoryHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/repository-handler", unknown>>;
 export interface RepositoryHandler<GenericRepository extends object = object> extends Kind<typeof repositoryHandlerKind.definition> {
-    createImplementation(implementation: {
-        [Prop in keyof GenericRepository]: GenericRepository[Prop] extends AnyFunction ? AnyFunction<Parameters<GenericRepository[Prop]>, ReturnType<GenericRepository[Prop]>> : GenericRepository[Prop];
-    }): GenericRepository;
+    createImplementation(implementation: SimplifyTopLevel<{
+        [Prop in keyof GenericRepository]: GenericRepository[Prop] extends AnyFunction ? (...args: Parameters<GenericRepository[Prop]>) => ReturnType<GenericRepository[Prop]> : GenericRepository[Prop];
+    }>): GenericRepository;
 }
 export declare function createRepository<GenericRepository extends object>(): RepositoryHandler<GenericRepository>;

package/dist/clean/useCase.cjs

@@ -4,6 +4,7 @@ var kind = require('./kind.cjs');
 var pipe = require('../common/pipe.cjs');
 var map = require('../array/map.cjs');
 var entry = require('../object/entry.cjs');
+var uncapitalize = require('../string/uncapitalize.cjs');
 var entries = require('../object/entries.cjs');
 var fromEntries = require('../object/fromEntries.cjs');
 
@@ -11,13 +12,13 @@ const useCaseHandlerKind = kind.createCleanKind("use-case-handler");
 function createUseCase(dependencies, getUseCase) {
     return useCaseHandlerKind.setTo({
         dependencies,
-        getUseCase: (repositories) => getUseCase(pipe.pipe(dependencies, entries.entries, map.map(([key, value]) => entry.entry(key, useCaseHandlerKind.has(value)
+        getUseCase: (repositories) => getUseCase(pipe.pipe(dependencies, entries.entries, map.map(([key, value]) => entry.entry(uncapitalize.uncapitalize(key), useCaseHandlerKind.has(value)
             ? value.getUseCase(repositories)
-            : repositories[key])), fromEntries.fromEntries)),
+            : repositories[uncapitalize.uncapitalize(key)])), fromEntries.fromEntries)),
     });
 }
 function useCaseInstances(useCases, repositories) {
-    return pipe.pipe(useCases, entries.entries, map.map(([key, useCase]) => entry.entry(key, useCase.getUseCase(repositories))), fromEntries.fromEntries);
+    return pipe.pipe(useCases, entries.entries, map.map(([key, useCase]) => entry.entry(uncapitalize.uncapitalize(key), useCase.getUseCase(repositories))), fromEntries.fromEntries);
 }
 
 exports.createUseCase = createUseCase;

package/dist/clean/useCase.d.ts

@@ -2,11 +2,11 @@ import { type ObjectEntry, type Kind, type SimplifyTopLevel, type UnionToInterse
 import { type RepositoryHandler } from "./repository";
 export type UseCaseDependencies = Record<string, RepositoryHandler | UseCaseHandler>;
 export type UseCaseDependenciesValue<GenericDependencies extends UseCaseDependencies> = SimplifyTopLevel<{
-    [Prop in keyof GenericDependencies]: GenericDependencies[Prop] extends RepositoryHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
+    [Prop in keyof GenericDependencies as (Prop extends string ? Uncapitalize<Prop> : Prop)]: GenericDependencies[Prop] extends RepositoryHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
 }>;
 export type GetAllRepositories<GenericDependenciesValue extends UseCaseDependencies> = GenericDependenciesValue extends any ? ({
     [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends RepositoryHandler ? [
-        Prop,
+        (Prop extends string ? Uncapitalize<Prop> : Prop),
         ReturnType<GenericDependenciesValue[Prop]["createImplementation"]>
     ] : GenericDependenciesValue[Prop] extends UseCaseHandler ? GetAllRepositories<GenericDependenciesValue[Prop]["dependencies"]> : never);
 })[keyof GenericDependenciesValue] : never;

package/dist/clean/useCase.mjs

@@ -2,6 +2,7 @@ import { createCleanKind } from './kind.mjs';
 import { pipe } from '../common/pipe.mjs';
 import { map } from '../array/map.mjs';
 import { entry } from '../object/entry.mjs';
+import { uncapitalize } from '../string/uncapitalize.mjs';
 import { entries } from '../object/entries.mjs';
 import { fromEntries } from '../object/fromEntries.mjs';
 
@@ -9,13 +10,13 @@ const useCaseHandlerKind = createCleanKind("use-case-handler");
 function createUseCase(dependencies, getUseCase) {
     return useCaseHandlerKind.setTo({
         dependencies,
-        getUseCase: (repositories) => getUseCase(pipe(dependencies, entries, map(([key, value]) => entry(key, useCaseHandlerKind.has(value)
+        getUseCase: (repositories) => getUseCase(pipe(dependencies, entries, map(([key, value]) => entry(uncapitalize(key), useCaseHandlerKind.has(value)
             ? value.getUseCase(repositories)
-            : repositories[key])), fromEntries)),
+            : repositories[uncapitalize(key)])), fromEntries)),
     });
 }
 function useCaseInstances(useCases, repositories) {
-    return pipe(useCases, entries, map(([key, useCase]) => entry(key, useCase.getUseCase(repositories))), fromEntries);
+    return pipe(useCases, entries, map(([key, useCase]) => entry(uncapitalize(key), useCase.getUseCase(repositories))), fromEntries);
 }
 
 export { createUseCase, useCaseHandlerKind, useCaseInstances };

package/dist/common/index.d.ts

@@ -13,7 +13,7 @@ export * from "./simpleClone";
 export * from "./sleep";
 export * from "./stringToBytes";
 export * from "./stringToMillisecond";
-export * from "./toJson";
+export * from "./toJSON";
 export * from "./toTransform";
 export * from "./toWrappedValue";
 export * from "./unwrap";

package/dist/common/{toJson.d.ts → toJSON.d.ts}

@@ -5,7 +5,7 @@ export type ToJSON<GenericValue extends unknown> = GenericValue extends number |
 }) ? ReturnType<GenericValue["toJSON"]> : GenericValue extends [infer InferredFirst, ...infer InferredRest] ? [
     ToJSON<InferredFirst>,
     ...(ToJSON<InferredRest> extends infer InferredSubRest extends any[] ? IsEqual<InferredSubRest, never[]> extends false ? InferredSubRest : [] : [])
-] : GenericValue extends any[] ? ToJSON<GenericValue[number]>[] : GenericValue extends Record<number, unknown> ? {
+] : GenericValue extends any[] ? ToJSON<GenericValue[number]>[] : GenericValue extends object ? {
     [Prop in keyof GenericValue as GenericValue[Prop] extends AnyFunction ? never : Prop]: ToJSON<GenericValue[Prop]>;
 } : undefined;
 export declare function toJSON<GenericValue extends unknown>(value: GenericValue): ToJSON<GenericValue>;

package/dist/dataParser/extended/object.cjs

@@ -10,10 +10,22 @@ var override = require('../../common/override.cjs');
 
 function object(shape, definition) {
     const self = baseExtended.dataParserExtendedInit(index.object(shape, definition), {
-        omit: (self, omitObject, definition) => omit.omit(self, omitObject, definition),
-        pick: (self, pickObject, definition) => pick.pick(self, pickObject, definition),
-        partial: (self, definition) => partial.partial(self, definition),
-        required: (self, definition) => required.required(self, definition),
+        omit: (self, omitObject, definition) => {
+            const newShape = omit.omitShape(self.definition.shape, omitObject);
+            return object(newShape, definition);
+        },
+        pick: (self, pickObject, definition) => {
+            const newShape = pick.pickShape(self.definition.shape, pickObject);
+            return object(newShape, definition);
+        },
+        partial: (self, definition) => {
+            const newShape = partial.partialShape(self.definition.shape);
+            return object(newShape, definition);
+        },
+        required: (self, definition) => {
+            const newShape = required.requiredShape(self.definition.shape);
+            return object(newShape, definition);
+        },
     });
     return object.overrideHandler.apply(self);
 }

package/dist/dataParser/extended/object.d.ts

@@ -1,4 +1,4 @@
-import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
+import { type Adaptor, type FixDeepFunctionInfer, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
@@ -16,10 +16,18 @@ export interface DataParserObjectExtended<GenericDefinition extends dataParsers.
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserObjectExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
-    omit<const GenericOmitObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(omitObject: GenericOmitObject, definition?: GenericDefinition): ReturnType<typeof dataParsers.omit<dataParsers.DataParserObject<GenericDefinition>, GenericOmitObject, GenericSubDefinition>>;
-    pick<const GenericPickObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(pickObject: GenericPickObject, definition?: GenericDefinition): ReturnType<typeof dataParsers.pick<dataParsers.DataParserObject<GenericDefinition>, GenericPickObject, GenericSubDefinition>>;
-    partial<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): ReturnType<typeof dataParsers.partial<dataParsers.DataParserObject<GenericDefinition>, GenericSubDefinition>>;
-    required<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): ReturnType<typeof dataParsers.required<dataParsers.DataParserObject<GenericDefinition>, GenericSubDefinition>>;
+    omit<const GenericOmitObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: SimplifyTopLevel<Omit<GenericDefinition["shape"], keyof GenericOmitObject>>;
+    }>>;
+    pick<const GenericPickObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(pickObject: GenericPickObject, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: SimplifyTopLevel<Pick<GenericDefinition["shape"], Adaptor<keyof GenericPickObject, keyof GenericDefinition["shape"]>>>;
+    }>>;
+    partial<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: dataParsers.PartialDataParserObject<GenericDefinition["shape"]>;
+    }>>;
+    required<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: dataParsers.RequireDataParserObject<GenericDefinition["shape"]>;
+    }>>;
 }
 export declare function object<const GenericShape extends dataParsers.DataParserObjectShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;

package/dist/dataParser/extended/object.mjs

@@ -1,17 +1,29 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { object as object$1 } from '../parsers/object/index.mjs';
-import { required } from '../parsers/object/required.mjs';
-import { partial } from '../parsers/object/partial.mjs';
-import { pick } from '../parsers/object/pick.mjs';
-import { omit } from '../parsers/object/omit.mjs';
+import { requiredShape } from '../parsers/object/required.mjs';
+import { partialShape } from '../parsers/object/partial.mjs';
+import { pickShape } from '../parsers/object/pick.mjs';
+import { omitShape } from '../parsers/object/omit.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 function object(shape, definition) {
     const self = dataParserExtendedInit(object$1(shape, definition), {
-        omit: (self, omitObject, definition) => omit(self, omitObject, definition),
-        pick: (self, pickObject, definition) => pick(self, pickObject, definition),
-        partial: (self, definition) => partial(self, definition),
-        required: (self, definition) => required(self, definition),
+        omit: (self, omitObject, definition) => {
+            const newShape = omitShape(self.definition.shape, omitObject);
+            return object(newShape, definition);
+        },
+        pick: (self, pickObject, definition) => {
+            const newShape = pickShape(self.definition.shape, pickObject);
+            return object(newShape, definition);
+        },
+        partial: (self, definition) => {
+            const newShape = partialShape(self.definition.shape);
+            return object(newShape, definition);
+        },
+        required: (self, definition) => {
+            const newShape = requiredShape(self.definition.shape);
+            return object(newShape, definition);
+        },
     });
     return object.overrideHandler.apply(self);
 }

package/dist/dataParser/identifier.d.ts

@@ -8,7 +8,7 @@ import { type DataParser } from "./base";
  * parsers, the correct type can be retrieved.
  */
 export declare const identifier: {
-    <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+    <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: string;
         output: string;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
@@ -57,7 +57,7 @@ export declare const identifier: {
         input: unknown[];
         output: unknown[];
     }>>, GenericInput extends DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericResult extends Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => import("../either").EitherSuccess<GenericResult> | (GenericInput extends any ? import("../common").IsEqual<GenericKindHandler extends any ? import("../common").IsEqual<false | (import("../common").GetKindHandler<GenericInput> extends infer T ? T extends import("../common").GetKindHandler<GenericInput> ? T extends any ? import("../common").IsEqual<T, GenericKindHandler> : never : never : never), boolean> : never, true> extends true ? import("../either").EitherSuccess<GenericInput> : import("../either").EitherError<GenericInput> : never);
-    <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+    <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: string;
         output: string;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {

package/dist/dataParser/index.cjs

@@ -87,9 +87,13 @@ exports.checkerStringRegexKind = regex.checkerStringRegexKind;
 exports.string = index$2.string;
 exports.stringKind = index$2.stringKind;
 exports.omit = omit.omit;
+exports.omitShape = omit.omitShape;
 exports.pick = pick.pick;
+exports.pickShape = pick.pickShape;
 exports.partial = partial.partial;
+exports.partialShape = partial.partialShape;
 exports.required = required.required;
+exports.requiredShape = required.requiredShape;
 exports.object = index$3.object;
 exports.objectKind = index$3.objectKind;
 exports.checkerInt = int.checkerInt;

package/dist/dataParser/index.mjs

@@ -12,10 +12,10 @@ export { checkerStringMax, checkerStringMaxKind } from './parsers/string/checker
 export { checkerStringMin, checkerStringMinKind } from './parsers/string/checkers/min.mjs';
 export { checkerStringRegex, checkerStringRegexKind } from './parsers/string/checkers/regex.mjs';
 export { string, stringKind } from './parsers/string/index.mjs';
-export { omit } from './parsers/object/omit.mjs';
-export { pick } from './parsers/object/pick.mjs';
-export { partial } from './parsers/object/partial.mjs';
-export { required } from './parsers/object/required.mjs';
+export { omit, omitShape } from './parsers/object/omit.mjs';
+export { pick, pickShape } from './parsers/object/pick.mjs';
+export { partial, partialShape } from './parsers/object/partial.mjs';
+export { required, requiredShape } from './parsers/object/required.mjs';
 export { object, objectKind } from './parsers/object/index.mjs';
 export { checkerInt, checkerIntKind, int } from './parsers/number/checkers/int.mjs';
 export { checkerNumberMin, checkerNumberMinKind } from './parsers/number/checkers/min.mjs';

package/dist/dataParser/parsers/array/index.d.ts

@@ -8,7 +8,7 @@ export * from "./checkers";
 export interface DataParserArrayCheckerCustom<GenericInput extends unknown[] = unknown[]> {
 }
 export type DataParserArrayCheckers<GenericInput extends unknown[] = unknown[]> = (DataParserArrayCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserArrayCheckerCustom<GenericInput>, DataParserChecker>] | DataParserCheckerArrayMin | DataParserCheckerArrayMax | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionArray extends DataParserDefinition {
+export interface DataParserDefinitionArray extends DataParserDefinition<DataParserArrayCheckers> {
     readonly element: DataParser;
 }
 export declare const arrayKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>>;

package/dist/dataParser/parsers/object/omit.cjs

@@ -7,9 +7,13 @@ var isKeyof = require('../../../string/isKeyof.cjs');
 var entries = require('../../../object/entries.cjs');
 var fromEntries = require('../../../object/fromEntries.cjs');
 
+function omitShape(shape, omitObject) {
+    return pipe.pipe(shape, entries.entries, filter.filter(([key]) => !isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
+}
 function omit(dataParser, omitObject, definition) {
-    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, filter.filter(([key]) => !isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
+    const newShape = omitShape(dataParser.definition.shape, omitObject);
     return index.object(newShape, definition);
 }
 
 exports.omit = omit;
+exports.omitShape = omitShape;