alepha 0.11.6 → 0.11.9

package/command.d.ts

@@ -201,8 +201,8 @@ declare class CliProvider {
   protected readonly runner: Runner;
   protected readonly asker: Asker;
   protected readonly options: Readonly<{
-    name?: string | undefined;
     description?: string | undefined;
+    name?: string | undefined;
     argv?: string[] | undefined;
   }>;
   protected get name(): string;

package/core.d.ts

@@ -1,9 +1,9 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Validator } from "typebox/compile";
-import * as TypeBoxValue from "typebox/value";
 import * as TypeBox from "typebox";
-import { Static as Static$1, StaticDecode, StaticDecode as Static, StaticDecode as StaticDecode$1, StaticEncode, StaticEncode as StaticEncode$1, TAny, TAny as TAny$1, TArray, TArray as TArray$1, TArrayOptions, TBigInt, TBoolean, TBoolean as TBoolean$1, TInteger, TInteger as TInteger$1, TKeysToIndexer, TKeysToIndexer as TKeysToIndexer$1, TNull, TNull as TNull$1, TNumber, TNumber as TNumber$1, TNumberOptions, TNumberOptions as TNumberOptions$1, TObject, TObject as TObject$1, TObjectOptions, TObjectOptions as TObjectOptions$1, TOmit, TOptional, TOptionalAdd, TOptionalAdd as TOptionalAdd$1, TPick, TPick as TPick$1, TProperties, TProperties as TProperties$1, TRecord, TRecord as TRecord$1, TSchema, TSchema as TSchema$1, TSchemaOptions, TString, TString as TString$1, TStringOptions, TStringOptions as TStringOptions$1, TTuple, TUnion, TUnion as TUnion$1, TUnsafe, TUnsafe as TUnsafe$1, TVoid } from "typebox";
+import { Static as Static$1, StaticDecode, StaticDecode as Static, StaticEncode, StaticEncode as StaticEncode$1, TAny, TAny as TAny$1, TArray, TArray as TArray$1, TArrayOptions, TBigInt, TBoolean, TBoolean as TBoolean$1, TInteger, TInteger as TInteger$1, TInterface, TKeysToIndexer, TKeysToIndexer as TKeysToIndexer$1, TNull, TNull as TNull$1, TNumber, TNumber as TNumber$1, TNumberOptions, TNumberOptions as TNumberOptions$1, TObject, TObject as TObject$1, TObjectOptions, TObjectOptions as TObjectOptions$1, TOmit, TOptional, TOptionalAdd, TOptionalAdd as TOptionalAdd$1, TPartial, TPick, TPick as TPick$1, TProperties, TProperties as TProperties$1, TRecord, TRecord as TRecord$1, TSchema, TSchema as TSchema$1, TSchemaOptions, TString, TString as TString$1, TStringOptions, TStringOptions as TStringOptions$1, TTuple, TUnion, TUnion as TUnion$1, TUnsafe, TUnsafe as TUnsafe$1, TVoid } from "typebox";
 import TypeBoxFormat from "typebox/format";
+import * as TypeBoxValue from "typebox/value";
 import { TLocalizedValidationError } from "typebox/error";
 import { Readable } from "node:stream";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
@@ -382,8 +382,11 @@ type TStream = TUnsafe$1<StreamLike>;
 declare const isUUID: typeof TypeBoxFormat.IsUuid;
 declare const isEmail: typeof TypeBoxFormat.IsEmail;
 declare const isURL: typeof TypeBoxFormat.IsUrl;
+declare const isDateTime: typeof TypeBoxFormat.IsDateTime;
+declare const isDate: typeof TypeBoxFormat.IsDate;
+declare const isTime: typeof TypeBoxFormat.IsTime;
+declare const isDuration: typeof TypeBoxFormat.IsDuration;
 declare class TypeGuard {
-  isFile: (value: TSchema$1) => value is TFile;
   isBigInt: (value: TSchema$1) => value is TString$1;
   isUUID: (value: TSchema$1) => value is TString$1;
   isObject: typeof TypeBox.IsObject;
@@ -403,6 +406,11 @@ declare class TypeGuard {
   isVoid: typeof TypeBox.IsVoid;
   isLiteral: typeof TypeBox.IsLiteral;
   isSchema: typeof TypeBox.IsSchema;
+  isFile: (value: TSchema$1) => value is TFile;
+  isDateTime: (schema: unknown) => boolean;
+  isDate: (schema: unknown) => boolean;
+  isTime: (schema: unknown) => boolean;
+  isDuration: (schema: unknown) => boolean;
 }
 declare module "typebox" {
   interface TString {
@@ -467,14 +475,11 @@ declare class TypeProvider {
   void: typeof TypeBox.Void;
   undefined: typeof TypeBox.Undefined;
   record: typeof TypeBox.Record;
-  partial: typeof TypeBox.Partial;
   union: typeof TypeBox.Union;
   tuple: typeof TypeBox.Tuple;
-  interface: typeof TypeBox.Interface;
   null: typeof TypeBox.Null;
   const: typeof TypeBox.Literal;
-  codec: typeof TypeBox.Codec;
-  literal: typeof TypeBox.Literal;
+  options: typeof TypeBox.Options;
   /**
    * Type guards to check the type of schema.
    * This is not a runtime type check, but a compile-time type guard.
@@ -487,8 +492,11 @@ declare class TypeProvider {
    * ```
    */
   readonly schema: TypeGuard;
+  extend<T extends TSchema$1[], U$1 extends TProperties$1>(schema: [...T], properties: U$1, options?: TSchemaOptions): TInterface<T, U$1>;
+  extend<T extends TObject$1, U$1 extends TProperties$1>(schema: T, properties: U$1, options?: TSchemaOptions): TInterface<[T], U$1>;
   pick<T extends TObject$1, Indexer extends PropertyKey[]>(schema: T, keys: [...Indexer], options?: TObjectOptions$1): TPick$1<T, TKeysToIndexer$1<Indexer>>;
   omit<T extends TObject$1, Indexer extends PropertyKey[]>(schema: T, keys: [...Indexer], options?: TObjectOptions$1): TOmit<T, TKeysToIndexer$1<Indexer>>;
+  partial<T extends TSchema$1>(schema: T, options?: TSchemaOptions): TPartial<T>;
   /**
    * Create a schema for an object.
    * By default, additional properties are not allowed.
@@ -575,18 +583,18 @@ declare class TypeProvider {
    */
   enum<T extends string[]>(values: [...T], options?: TStringOptions$1): TUnsafe$1<T[number]>;
   /**
-   * Create a schema for a bigint.
-   * This is NOT a BigInt object, but a string that represents a bigint.
+   * Create a schema for a bigint represented as a string.
+   * This is a string that validates bigint format (e.g. "123456789").
    */
-  bigint(options?: TStringOptions$1): TypeBox.TCodec<TString$1, bigint>;
+  bigint(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for a url.
+   * Create a schema for a URL represented as a string.
    */
-  url(options?: TStringOptions$1): TypeBox.TCodec<TString$1, URL>;
+  url(options?: TStringOptions$1): TString$1;
   /**
-   * Create a schema for binary data represented as a string.
+   * Create a schema for binary data represented as a base64 string.
    */
-  binary(options: TStringOptions$1): TypeBox.TCodec<TString$1, Uint8Array<ArrayBuffer>>;
+  binary(options: TStringOptions$1): TString$1;
   /**
    * Create a schema for uuid.
    */
@@ -635,6 +643,10 @@ declare class TypeProvider {
     label: TString$1;
     description: TypeBox.TOptional<TString$1>;
   }>;
+  datetime: (options?: TStringOptions$1) => TString$1;
+  date: (options?: TStringOptions$1) => TString$1;
+  time: (options?: TStringOptions$1) => TString$1;
+  duration: (options?: TStringOptions$1) => TString$1;
 }
 type TextLength = "short" | "regular" | "long" | "rich";
 interface TTextOptions extends TStringOptions$1 {
@@ -662,61 +674,56 @@ declare const t: TypeProvider;
 //#endregion
 //#region src/providers/SchemaCodec.d.ts
 declare abstract class SchemaCodec {
-  protected cache: Map<TSchema$1, Validator>;
-  protected guard: TypeGuard;
   /**
    * Encode the value to a string format.
    */
-  abstract encodeToString(schema: TSchema$1, value: any): string;
+  abstract encodeToString<T extends TSchema>(schema: T, value: Static<T>): string;
   /**
    * Encode the value to a binary format.
    */
-  abstract encodeToBinary(schema: TSchema$1, value: any): Uint8Array;
+  abstract encodeToBinary<T extends TSchema>(schema: T, value: Static<T>): Uint8Array;
   /**
-   * Transform a specific type for this codec.
-   * Return undefined to use the default schema, or return a new schema to replace it.
-   *
-   * Override this method to customize how specific types are handled in this codec.
-   * For example, a ProtobufCodec might keep BigInt as-is instead of converting to string.
+   * Decode string, binary, or other formats to the schema type.
    */
-  protected abstract transformType(schema: TSchema$1): TSchema$1 | false | void;
-  encode<T extends TSchema$1>(schema: T, value: any): StaticEncode$1<T>;
-  decode<T extends TSchema$1>(schema: T, value: any): StaticDecode$1<T>;
-  protected validator<T extends TSchema$1>(schema: T): Validator<{}, T>;
-  /**
-   * Transform the schema for this codec.
-   * Override this method to provide custom schema transformations.
-   * This method should recursively transform all nested schemas.
-   */
-  protected transformSchema<T extends TSchema$1>(schema: T): TSchema$1;
+  abstract decode<T>(schema: TSchema, value: unknown): T;
+}
+//#endregion
+//#region src/providers/JsonSchemaCodec.d.ts
+declare class JsonSchemaCodec extends SchemaCodec {
+  protected readonly json: Json;
+  protected readonly encoder: TextEncoder;
+  protected readonly decoder: TextDecoder;
+  encodeToString<T extends TSchema$1>(schema: T, value: Static<T>): string;
+  encodeToBinary<T extends TSchema$1>(schema: T, value: Static<T>): Uint8Array;
+  decode<T>(schema: TSchema$1, value: unknown): T;
+}
+//#endregion
+//#region src/providers/SchemaValidator.d.ts
+declare class SchemaValidator {
+  protected cache: Map<TSchema$1, Validator<TypeBox.TProperties, TSchema$1>>;
   /**
-   * Preprocess the value based on the schema before encoding.
+   * Validate the value against the provided schema.
    *
-   * - Remove `undefined` values from objects. { a: 1, b: undefined } => { a: 1 }
+   * Validation create a new value by applying some preprocessing. (e.g., trimming text)
    */
-  beforeEncode: (schema: any, value: any) => any;
+  validate<T extends TSchema$1>(schema: T, value: unknown, options?: ValidateOptions): Static<T>;
+  protected getValidator<T extends TSchema$1>(schema: T): Validator<{}, T>;
   /**
    * Preprocess the value based on the schema before validation.
    *
    * - If the value is `null` and the schema does not allow `null`, it converts it to `undefined`.
    * - If the value is a string and the schema has a `~options.trim` flag, it trims whitespace from the string.
    */
-  beforeDecode: (schema: any, value: any) => any;
+  beforeParse(schema: any, value: any, options: ValidateOptions): any;
   /**
-   * Used by `preprocess` to determine if a schema allows null values.
+   * Used by `beforeParse` to determine if a schema allows null values.
    */
   protected isSchemaNullable: (schema: any) => boolean;
 }
-//#endregion
-//#region src/providers/JsonSchemaCodec.d.ts
-declare class JsonSchemaCodec extends SchemaCodec {
-  protected readonly json: Json;
-  protected readonly encoder: TextEncoder;
-  protected readonly decoder: TextDecoder;
-  protected transformType(schema: TSchema$1): TSchema$1 | false | void;
-  encodeToString(schema: TSchema$1, value: any): string;
-  encodeToBinary(schema: TSchema$1, value: any): Uint8Array;
-  decode<T extends TSchema$1>(schema: T, value: any): StaticDecode$1<T>;
+interface ValidateOptions {
+  trim?: boolean;
+  nullToUndefined?: boolean;
+  deleteUndefined?: boolean;
 }
 //#endregion
 //#region src/providers/CodecManager.d.ts
@@ -724,24 +731,35 @@ type Encoding = "object" | "string" | "binary";
 interface EncodeOptions<T extends Encoding = Encoding> {
   /**
    * The output encoding format:
-   * - 'object': Returns native types (objects, BigInt, Date, etc.)
    * - 'string': Returns JSON string
    * - 'binary': Returns Uint8Array (for protobuf, msgpack, etc.)
+   *
+   * @default "string"
    */
   as?: T;
   /**
    * The encoder to use (e.g., 'json', 'protobuf', 'msgpack')
-   * Defaults to 'json'
+   *
+   * @default "json"
    */
   encoder?: string;
+  /**
+   * Validation options to apply before encoding.
+   */
+  validation?: ValidateOptions | false;
 }
 type EncodeResult<T extends TSchema$1, E extends Encoding> = E extends "string" ? string : E extends "binary" ? Uint8Array : StaticEncode$1<T>;
 interface DecodeOptions {
   /**
    * The encoder to use (e.g., 'json', 'protobuf', 'msgpack')
-   * Defaults to 'json'
+   *
+   * @default "json"
    */
   encoder?: string;
+  /**
+   * Validation options to apply before encoding.
+   */
+  validation?: ValidateOptions | false;
 }
 /**
  * CodecManager manages multiple codec formats and provides a unified interface
@@ -750,33 +768,38 @@ interface DecodeOptions {
 declare class CodecManager {
   protected readonly codecs: Map<string, SchemaCodec>;
   protected readonly jsonCodec: JsonSchemaCodec;
+  protected readonly schemaValidator: SchemaValidator;
   default: string;
   constructor();
   /**
    * Register a new codec format.
+   *
    * @param name - The name of the codec (e.g., 'json', 'protobuf')
    * @param codec - The codec implementation
    */
   register(name: string, codec: SchemaCodec): void;
   /**
    * Get a specific codec by name.
+   *
    * @param name - The name of the codec
    * @returns The codec instance
    * @throws {AlephaError} If the codec is not found
    */
-  get(name: string): SchemaCodec;
+  getCodec(name: string): SchemaCodec;
   /**
    * Encode data using the specified codec and output format.
    */
-  encode<T extends TSchema$1, E extends Encoding = "object">(schema: T, value: any, options?: EncodeOptions<E>): EncodeResult<T, E>;
+  encode<T extends TSchema$1, E extends Encoding = "object">(schema: T, value: unknown, options?: EncodeOptions<E>): EncodeResult<T, E>;
   /**
    * Decode data using the specified codec.
    */
-  decode<T extends TSchema$1>(schema: T, value: any, options?: DecodeOptions): StaticDecode$1<T>;
+  decode<T extends TSchema$1>(schema: T, data: any, options?: DecodeOptions): Static<T>;
   /**
-   * Validate decoded data.
+   * Validate decoded data against the schema.
+   *
+   * This is automatically called before encoding or after decoding.
    */
-  validate<T extends TSchema$1>(schema: T, value: any, options?: DecodeOptions): StaticDecode$1<T>;
+  validate<T extends TSchema$1>(schema: T, value: unknown, options?: ValidateOptions): Static<T>;
 }
 //#endregion
 //#region src/providers/EventManager.d.ts
@@ -852,23 +875,27 @@ declare class EventManager {
  * If you need to store complex data, consider using identifiers or references instead.
  */
 declare const $atom: {
-  <T extends TObject, N extends string>(options: AtomOptions<T, N>): Atom<T, N>;
+  <T extends TObject<TProperties$2> | TArray$1, N extends string>(options: AtomOptions<T, N>): Atom<T, N>;
   [KIND]: string;
 };
-type AtomOptions<T extends TObject, N extends string> = {
+type AtomOptions<T extends TAtomObject, N extends string> = {
   name: N;
   schema: T;
-} & (T extends TOptionalAdd$1<T> ? {
+  description?: string;
+} & (T extends TOptionalAdd<T> ? {
   default?: Static<T>;
 } : {
   default: Static<T>;
 });
-declare class Atom<T extends TObject = TObject, N extends string = string> {
+declare class Atom<T extends TAtomObject = TObject, N extends string = string> {
   readonly options: AtomOptions<T, N>;
   get schema(): T;
   get key(): N;
   constructor(options: AtomOptions<T, N>);
 }
+type TProperties$2 = any;
+type TAtomObject = TObject<any> | TArray$1;
+type AtomStatic<T extends TAtomObject> = T extends TOptionalAdd<T> ? Static<T> | undefined : Static<T>;
 //#endregion
 //#region src/providers/StateManager.d.ts
 interface AtomWithValue {
@@ -887,12 +914,12 @@ declare class StateManager<State$1 extends object = State> {
   /**
    * Get a value from the state with proper typing
    */
-  get<T extends TObject$1>(target: Atom<T>): Static<T>;
+  get<T extends TAtomObject>(target: Atom<T>): Static<T>;
   get<Key extends keyof State$1>(target: Key): State$1[Key] | undefined;
   /**
    * Set a value in the state
    */
-  set<T extends TObject$1>(target: Atom<T>, value: Static<T>): this;
+  set<T extends TAtomObject>(target: Atom<T>, value: AtomStatic<T>): this;
   set<Key extends keyof State$1>(target: Key, value: State$1[Key] | undefined): this;
   /**
    * Mutate a value in the state.
@@ -1873,5 +1900,5 @@ type PageQuery = Static<typeof pageQuerySchema>;
  */
 declare const run: (entry: Alepha | Service | Array<Service>, opts?: RunOptions) => Alepha;
 //#endregion
-export { $atom, $context, $env, $hook, $inject, $module, $use, AbstractClass, Alepha, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, Atom, AtomOptions, AtomWithValue, CircularDependencyError, CodecManager, ContainerLockedError, ContextDescriptor, DecodeOptions, Descriptor, DescriptorArgs, DescriptorConfig, DescriptorFactory, DescriptorFactoryLike, EncodeOptions, EncodeResult, Encoding, Env, FileLike, Hook, HookDescriptor, HookOptions, Hooks, InjectDescriptor, InjectOptions, InstantiableClass, JsonSchemaCodec, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModuleDescriptorOptions, OPTIONS, Page, PageMetadata, PageQuery, PageRequest, RunFunction, SchemaCodec, Service, ServiceEntry, ServiceSubstitution, SortDirection, SortField, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, TPage, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TUnsafe, type TVoid, TextLength, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxErrorParams, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, WithModule, boot, createDescriptor, createPagination, isClass, isEmail, isFileLike, isTypeFile, isURL, isUUID, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
+export { $atom, $context, $env, $hook, $inject, $module, $use, AbstractClass, Alepha, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, Atom, AtomOptions, AtomStatic, AtomWithValue, CircularDependencyError, CodecManager, ContainerLockedError, ContextDescriptor, DecodeOptions, Descriptor, DescriptorArgs, DescriptorConfig, DescriptorFactory, DescriptorFactoryLike, EncodeOptions, EncodeResult, Encoding, Env, FileLike, Hook, HookDescriptor, HookOptions, Hooks, InjectDescriptor, InjectOptions, InstantiableClass, JsonSchemaCodec, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModuleDescriptorOptions, OPTIONS, Page, PageMetadata, PageQuery, PageRequest, RunFunction, SchemaCodec, Service, ServiceEntry, ServiceSubstitution, SortDirection, SortField, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, TAtomObject, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, TPage, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TUnsafe, type TVoid, TextLength, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxErrorParams, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, WithModule, boot, createDescriptor, createPagination, isClass, isDate, isDateTime, isDuration, isEmail, isFileLike, isTime, isTypeFile, isURL, isUUID, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
 //# sourceMappingURL=index.d.ts.map

package/datetime.d.ts

@@ -1,5 +1,5 @@
 import * as _alepha_core1 from "alepha";
-import { Alepha, Descriptor, KIND, TStringOptions } from "alepha";
+import { Alepha, Descriptor, KIND } from "alepha";
 import "dayjs/plugin/relativeTime.js";
 import dayjsDuration from "dayjs/plugin/duration.js";
 import "dayjs/plugin/utc.js";
@@ -8,24 +8,13 @@ import "dayjs/plugin/localizedFormat.js";
 import "dayjs/locale/ar.js";
 import "dayjs/locale/fr.js";
 import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
-import * as typebox0 from "typebox";
-import * as dayjs_plugin_duration0 from "dayjs/plugin/duration";
 
-//#region src/providers/DateTimeTypeProvider.d.ts
-declare const datetime: (options?: TStringOptions) => typebox0.TCodec<typebox0.TString, DayjsApi.Dayjs>;
-declare const date: (options?: TStringOptions) => typebox0.TCodec<typebox0.TString, DayjsApi.Dayjs>;
-declare const time: (options?: TStringOptions) => typebox0.TCodec<typebox0.TString, DayjsApi.Dayjs>;
-declare const duration: (options?: TStringOptions) => typebox0.TCodec<typebox0.TString, dayjs_plugin_duration0.Duration>;
-declare const isDateTimeSchema: (schema: unknown) => schema is ReturnType<typeof datetime>;
-declare const isDateSchema: (schema: unknown) => schema is ReturnType<typeof date>;
-declare const isTimeSchema: (schema: unknown) => schema is ReturnType<typeof time>;
-declare const isDurationSchema: (schema: unknown) => schema is ReturnType<typeof duration>;
-//#endregion
 //#region src/providers/DateTimeProvider.d.ts
 type DateTime = DayjsApi.Dayjs;
 type Duration = dayjsDuration.Duration;
 type DurationLike = number | dayjsDuration.Duration | [number, ManipulateType];
 declare const dayjs: typeof DayjsApi;
+declare const isDateTime: (value: unknown) => value is DateTime;
 declare class DateTimeProvider {
   static PLUGINS: Array<PluginFunc<any>>;
   protected alepha: Alepha;
@@ -149,21 +138,7 @@ declare class IntervalDescriptor extends Descriptor<IntervalDescriptorOptions> {
 }
 //#endregion
 //#region src/index.d.ts
-declare module "alepha" {
-  interface TypeProvider {
-    datetime: typeof datetime;
-    date: typeof date;
-    time: typeof time;
-    duration: typeof duration;
-  }
-  interface TypeGuard {
-    isDateTime: typeof isDateTimeSchema;
-    isDate: typeof isDateSchema;
-    isTime: typeof isTimeSchema;
-    isDuration: typeof isDurationSchema;
-  }
-}
 declare const AlephaDateTime: _alepha_core1.Service<_alepha_core1.Module>;
 //#endregion
-export { $interval, AlephaDateTime, DateTime, DateTimeProvider, Duration, DurationLike, Interval, IntervalDescriptor, IntervalDescriptorOptions, Timeout, date, datetime, dayjs, duration, isDateSchema, isDateTimeSchema, isDurationSchema, isTimeSchema, time };
+export { $interval, AlephaDateTime, DateTime, DateTimeProvider, Duration, DurationLike, Interval, IntervalDescriptor, IntervalDescriptorOptions, Timeout, dayjs, isDateTime };
 //# sourceMappingURL=index.d.ts.map