@nmtjs/type 0.10.2 → 0.10.4

package/src/types/base.ts

@@ -1,53 +1,27 @@
-import {
-  _default,
-  core,
-  nullable,
-  optional,
-  registry,
-  type ZodMiniAny,
-  type ZodMiniArray,
-  type ZodMiniBoolean,
-  type ZodMiniCustom,
-  type ZodMiniDefault,
-  type ZodMiniEnum,
-  type ZodMiniInterface,
-  type ZodMiniIntersection,
-  type ZodMiniLiteral,
-  type ZodMiniNever,
-  type ZodMiniNullable,
-  type ZodMiniNumber,
-  type ZodMiniObject,
-  type ZodMiniOptional,
-  type ZodMiniPipe,
-  type ZodMiniRecord,
-  type ZodMiniString,
-  type ZodMiniType,
-  type ZodMiniUnion,
-} from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 
 export type PrimitiveValueType = string | number | boolean | null
 
 export type PrimitiveZodType =
-  | ZodMiniNever
-  | ZodMiniDefault
-  | ZodMiniNullable
-  | ZodMiniOptional
-  | ZodMiniString
-  | ZodMiniObject
-  | ZodMiniAny
-  | ZodMiniArray
-  | ZodMiniBoolean
-  | ZodMiniNumber
-  | ZodMiniEnum<any>
-  | ZodMiniLiteral<PrimitiveValueType>
-  | ZodMiniUnion
-  | ZodMiniIntersection
-  | ZodMiniInterface
-  | ZodMiniRecord
-
-export type SimpleZodType = ZodMiniType
-
-export type ZodType = SimpleZodType | ZodMiniType
+  | zod.ZodMiniNever
+  | zod.ZodMiniDefault
+  | zod.ZodMiniNullable
+  | zod.ZodMiniOptional
+  | zod.ZodMiniString
+  | zod.ZodMiniObject
+  | zod.ZodMiniAny
+  | zod.ZodMiniArray
+  | zod.ZodMiniBoolean
+  | zod.ZodMiniNumber
+  | zod.ZodMiniEnum<any>
+  | zod.ZodMiniLiteral<PrimitiveValueType>
+  | zod.ZodMiniUnion
+  | zod.ZodMiniIntersection
+  | zod.ZodMiniRecord
+
+export type SimpleZodType = zod.ZodMiniType
+
+export type ZodType = SimpleZodType | zod.ZodMiniType
 
 export type TypeProps = Record<string, any>
 
@@ -61,7 +35,7 @@ export type TypeMetadata<T = any> = {
 export type TypeParams = {
   encode?: (value: any) => any
   metadata?: TypeMetadata
-  checks: Array<core.CheckFn<any> | core.$ZodCheck<any>>
+  checks: Array<zod.core.CheckFn<any> | zod.core.$ZodCheck<any>>
 }
 
 export type DefaultTypeParams = {
@@ -71,13 +45,13 @@ export type DefaultTypeParams = {
 
 export type BaseTypeAny<
   EncodedZodType extends SimpleZodType = SimpleZodType,
-  DecodedZodType extends ZodType = ZodMiniType,
+  DecodedZodType extends ZodType = zod.ZodMiniType,
 > = BaseType<EncodedZodType, DecodedZodType, TypeProps>
 
-export const typesRegistry = registry<TypeMetadata>()
+export const typesRegistry = zod.registry<TypeMetadata>()
 
-export const NeemataTypeError = core.$ZodError
-export type NeemataTypeError = core.$ZodError
+export const NeemataTypeError = zod.core.$ZodError
+export type NeemataTypeError = zod.core.$ZodError
 
 export abstract class BaseType<
   EncodedZodType extends SimpleZodType = SimpleZodType,
@@ -162,13 +136,13 @@ export abstract class BaseType<
 export class OptionalType<
   Type extends BaseTypeAny = BaseTypeAny,
 > extends BaseType<
-  ZodMiniOptional<Type['encodedZodType']>,
-  ZodMiniOptional<Type['decodedZodType']>,
+  zod.ZodMiniOptional<Type['encodedZodType']>,
+  zod.ZodMiniOptional<Type['decodedZodType']>,
   { inner: Type }
 > {
   static factory<T extends BaseTypeAny>(type: T) {
     return new OptionalType<T>({
-      encodedZodType: optional(type.encodedZodType) as any,
+      encodedZodType: zod.optional(type.encodedZodType) as any,
       props: { inner: type },
     })
   }
@@ -177,13 +151,13 @@ export class OptionalType<
 export class NullableType<
   Type extends BaseTypeAny<any> = BaseTypeAny<any>,
 > extends BaseType<
-  ZodMiniNullable<Type['encodedZodType']>,
-  ZodMiniNullable<Type['decodedZodType']>,
+  zod.ZodMiniNullable<Type['encodedZodType']>,
+  zod.ZodMiniNullable<Type['decodedZodType']>,
   { inner: Type }
 > {
   static factory<T extends BaseTypeAny<any>>(type: T) {
     return new NullableType<T>({
-      encodedZodType: nullable(type.encodedZodType),
+      encodedZodType: zod.nullable(type.encodedZodType),
       props: { inner: type },
     })
   }
@@ -192,17 +166,17 @@ export class NullableType<
 export class DefaultType<
   Type extends BaseTypeAny = BaseTypeAny,
 > extends BaseType<
-  ZodMiniDefault<Type['encodedZodType']>,
-  ZodMiniDefault<Type['decodedZodType']>,
+  zod.ZodMiniDefault<Type['encodedZodType']>,
+  zod.ZodMiniDefault<Type['decodedZodType']>,
   { inner: Type }
 > {
   static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {
     return new DefaultType<T>({
-      encodedZodType: _default(
+      encodedZodType: zod._default(
         type.encodedZodType,
         type.params.encode?.(defaultValue) ?? defaultValue,
       ) as any,
-      decodedZodType: _default(type.decodedZodType, defaultValue) as any,
+      decodedZodType: zod._default(type.decodedZodType, defaultValue) as any,
       props: { inner: type },
     })
   }

package/src/types/boolean.ts

@@ -1,10 +1,12 @@
-import { boolean, type ZodMiniBoolean } from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType } from './base.ts'
 
-export class BooleanType extends BaseType<ZodMiniBoolean<boolean>> {
+export class BooleanType extends BaseType<zod.ZodMiniBoolean<boolean>> {
   static factory() {
     return new BooleanType({
-      encodedZodType: boolean(),
+      encodedZodType: zod.boolean(),
     })
   }
 }
+
+export const boolean = BooleanType.factory

package/src/types/custom.ts

@@ -1,45 +1,39 @@
-import {
-  any,
-  type core,
-  custom,
-  overwrite,
-  pipe,
-  refine,
-  type ZodMiniPipe,
-  type ZodMiniType,
-} from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType, type SimpleZodType, type ZodType } from './base.ts'
 
 export type CustomTransformFn<I, O> = (value: I) => O
 export abstract class TransformType<
   Type,
-  EncodedType extends SimpleZodType = ZodMiniType<Type, Type>,
-  DecodedType extends ZodType = ZodMiniType<Type, Type>,
+  EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>,
+  DecodedType extends ZodType = zod.ZodMiniType<Type, Type>,
 > extends BaseType<
-  ZodMiniPipe<
-    ZodMiniType<DecodedType['_zod']['output'], DecodedType['_zod']['input']>,
+  zod.ZodMiniPipe<
+    zod.ZodMiniType<
+      DecodedType['_zod']['output'],
+      DecodedType['_zod']['input']
+    >,
     EncodedType
   >,
-  ZodMiniPipe<
+  zod.ZodMiniPipe<
     EncodedType,
-    ZodMiniType<EncodedType['_zod']['output'], EncodedType['_zod']['input']>
+    zod.ZodMiniType<EncodedType['_zod']['output'], EncodedType['_zod']['input']>
   >
 > {}
 
 export class CustomType<
   Type,
-  EncodedType extends SimpleZodType = ZodMiniType<Type, Type>,
-  DecodedType extends ZodType = ZodMiniType<Type, Type>,
+  EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>,
+  DecodedType extends ZodType = zod.ZodMiniType<Type, Type>,
 > extends TransformType<Type, EncodedType, DecodedType> {
   static factory<
     Type,
-    EncodedType extends SimpleZodType = ZodMiniType<Type, Type>,
-    DecodedType extends ZodType = ZodMiniType<Type, Type>,
+    EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>,
+    DecodedType extends ZodType = zod.ZodMiniType<Type, Type>,
   >({
     decode,
     encode,
     error,
-    type = any() as unknown as EncodedType,
+    type = zod.any() as unknown as EncodedType,
   }: {
     decode: CustomTransformFn<
       EncodedType['_zod']['input'],
@@ -49,25 +43,37 @@ export class CustomType<
       DecodedType['_zod']['input'],
       EncodedType['_zod']['output']
     >
-    error?: string | core.$ZodErrorMap<core.$ZodIssueBase>
+    error?: string | zod.core.$ZodErrorMap<zod.core.$ZodIssueBase>
     type?: EncodedType
   }) {
     return new CustomType<Type, EncodedType, DecodedType>({
-      encodedZodType: pipe(
-        custom().check(
-          refine((val) => typeof val !== 'undefined', { error, abort: true }),
-          overwrite(encode),
+      encodedZodType: zod.pipe(
+        zod.custom().check(
+          zod.refine((val) => typeof val !== 'undefined', {
+            error,
+            abort: true,
+          }),
+          zod.overwrite(encode),
         ),
         type,
       ),
-      decodedZodType: pipe(
+      // @ts-expect-error
+      decodedZodType: zod.pipe(
         type,
-        custom().check(
-          refine((val) => typeof val !== 'undefined', { error, abort: true }),
-          overwrite(decode),
-        ),
+        // @ts-expect-error
+        zod
+          .custom()
+          .check(
+            zod.refine((val) => typeof val !== 'undefined', {
+              error,
+              abort: true,
+            }),
+            zod.overwrite(decode),
+          ),
       ),
       params: { encode },
     })
   }
 }
+
+export const custom = CustomType.factory

package/src/types/date.ts

@@ -1,18 +1,22 @@
-import { iso, union, type ZodMiniUnion } from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { CustomType, TransformType } from './custom.ts'
 
 export class DateType extends TransformType<
   Date,
-  ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>
+  zod.ZodMiniUnion<[zod.iso.ZodMiniISODate, zod.iso.ZodMiniISODateTime]>
 > {
   static factory() {
     return CustomType.factory<
       Date,
-      ZodMiniUnion<Array<iso.ZodMiniISODate | iso.ZodMiniISODateTime>>
+      zod.ZodMiniUnion<
+        Array<zod.iso.ZodMiniISODate | zod.iso.ZodMiniISODateTime>
+      >
     >({
       decode: (value: string): Date => new Date(value),
       encode: (value: Date): string => value.toISOString(),
-      type: union([iso.datetime(), iso.date()]),
+      type: zod.union([zod.iso.datetime(), zod.iso.date()]),
     })
   }
 }
+
+export const date = DateType.factory

package/src/types/enum.ts

@@ -1,17 +1,21 @@
-import { type core, enum as enum_, type ZodMiniEnum } from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType } from './base.ts'
 
 export class EnumType<
-  T extends core.util.EnumLike = core.util.EnumLike,
-> extends BaseType<ZodMiniEnum<T>, ZodMiniEnum<T>, { values: T }> {
-  static factory<T extends core.util.EnumLike>(values: T): EnumType<T>
+  T extends zod.core.util.EnumLike = zod.core.util.EnumLike,
+> extends BaseType<zod.ZodMiniEnum<T>, zod.ZodMiniEnum<T>, { values: T }> {
+  static factory<T extends zod.core.util.EnumLike>(values: T): EnumType<T>
   static factory<T extends string[]>(
     values: T,
-  ): EnumType<core.util.ToEnum<T[number]>>
-  static factory<T extends core.util.EnumLike | string[]>(values: T) {
+  ): EnumType<zod.core.util.ToEnum<T[number]>>
+  static factory<T extends zod.core.util.EnumLike | string[]>(values: T) {
     return new EnumType({
-      encodedZodType: enum_(values as any),
+      encodedZodType: zod.enum(values as any),
       props: { values },
     })
   }
 }
+
+const _enum = EnumType.factory
+
+export { _enum as enum }

package/src/types/literal.ts

@@ -1,13 +1,15 @@
-import { literal, type ZodMiniLiteral } from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType, type PrimitiveValueType } from './base.ts'
 
 export class LiteralType<
   T extends PrimitiveValueType = PrimitiveValueType,
-> extends BaseType<ZodMiniLiteral<T>, ZodMiniLiteral<T>, { value: T }> {
+> extends BaseType<zod.ZodMiniLiteral<T>, zod.ZodMiniLiteral<T>, { value: T }> {
   static factory<T extends PrimitiveValueType>(value: T) {
     return new LiteralType<T>({
-      encodedZodType: literal(value),
+      encodedZodType: zod.literal(value),
       props: { value },
     })
   }
 }
+
+export const literal = LiteralType.factory

package/src/types/never.ts

@@ -1,10 +1,12 @@
-import { never, type ZodMiniNever } from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType } from './base.ts'
 
-export class NeverType extends BaseType<ZodMiniNever> {
+export class NeverType extends BaseType<zod.ZodMiniNever> {
   static factory() {
     return new NeverType({
-      encodedZodType: never(),
+      encodedZodType: zod.never(),
     })
   }
 }
+
+export const never = NeverType.factory

package/src/types/number.ts

@@ -1,70 +1,65 @@
-import {
-  type core,
-  gt,
-  gte,
-  int,
-  lt,
-  lte,
-  number,
-  regex,
-  string,
-  type ZodMiniNumber,
-  type ZodMiniString,
-} from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType } from './base.ts'
 import { CustomType, TransformType } from './custom.ts'
 
-type Check = core.CheckFn<number> | core.$ZodCheck<number>
+type Check = zod.core.CheckFn<number> | zod.core.$ZodCheck<number>
 
 export class NumberType extends BaseType<
-  ZodMiniNumber<number>,
-  ZodMiniNumber<number>
+  zod.ZodMiniNumber<number>,
+  zod.ZodMiniNumber<number>
 > {
   static factory(...checks: Check[]) {
     return new NumberType({
-      encodedZodType: number().check(...checks),
+      encodedZodType: zod.number().check(...checks),
       params: { checks },
     })
   }
 
   positive() {
-    return NumberType.factory(...this.params.checks, gte(0))
+    return NumberType.factory(...this.params.checks, zod.gte(0))
   }
 
   negative() {
-    return NumberType.factory(...this.params.checks, lte(0))
+    return NumberType.factory(...this.params.checks, zod.lte(0))
   }
 
   lt(value: number) {
-    return NumberType.factory(...this.params.checks, lt(value))
+    return NumberType.factory(...this.params.checks, zod.lt(value))
   }
 
   lte(value: number) {
-    return NumberType.factory(...this.params.checks, lte(value))
+    return NumberType.factory(...this.params.checks, zod.lte(value))
   }
 
   gte(value: number) {
-    return NumberType.factory(...this.params.checks, gte(value))
+    return NumberType.factory(...this.params.checks, zod.gte(value))
   }
 
   gt(value: number) {
-    return NumberType.factory(...this.params.checks, gt(value))
+    return NumberType.factory(...this.params.checks, zod.gt(value))
   }
 }
 
 export class IntegerType extends NumberType {
   static factory(...checks: Check[]) {
-    return NumberType.factory(...checks, int())
+    return NumberType.factory(...checks, zod.int())
   }
 }
 
-export class BigIntType extends TransformType<bigint, ZodMiniString<string>> {
+export class BigIntType extends TransformType<
+  bigint,
+  zod.ZodMiniString<string>
+> {
   static factory() {
-    return CustomType.factory<bigint, ZodMiniString<string>>({
+    return CustomType.factory<bigint, zod.ZodMiniString<string>>({
       decode: (value) => BigInt(value),
       encode: (value) => value.toString(),
-      type: string().check(regex(/^-?\d+$/)),
+      type: zod.string().check(zod.regex(/^-?\d+$/)),
       error: 'Invalid bigint format',
     })
   }
 }
+
+export const number = NumberType.factory
+export const integer = IntegerType.factory
+export const bigInt = BigIntType.factory

package/src/types/object.ts

@@ -1,11 +1,4 @@
-import {
-  type core,
-  object,
-  record,
-  strictObject,
-  type ZodMiniObject,
-  type ZodMiniRecord,
-} from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 
 import { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'
 import { EnumType } from './enum.ts'
@@ -15,8 +8,14 @@ import type { StringType } from './string.ts'
 export type ObjectTypeProps = { [k: string]: BaseTypeAny }
 export type AnyObjectType = ObjectType<ObjectTypeProps>
 export class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<
-  ZodMiniObject<{ [K in keyof T]: T[K]['encodedZodType'] }, {}>,
-  ZodMiniObject<{ [K in keyof T]: T[K]['decodedZodType'] }, {}>,
+  zod.ZodMiniObject<
+    { [K in keyof T]: T[K]['encodedZodType'] },
+    zod.core.$strict
+  >,
+  zod.ZodMiniObject<
+    { [K in keyof T]: T[K]['decodedZodType'] },
+    zod.core.$strict
+  >,
   { properties: T }
 > {
   static factory<T extends ObjectTypeProps = {}>(properties: T) {
@@ -33,8 +32,8 @@ export class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<
     }
 
     return new ObjectType<T>({
-      encodedZodType: object(encodeProperties),
-      decodedZodType: object(decodeProperties),
+      encodedZodType: zod.object(encodeProperties),
+      decodedZodType: zod.object(decodeProperties),
       props: { properties },
     })
   }
@@ -44,19 +43,19 @@ export class RecordType<
   K extends LiteralType<string | number> | EnumType | StringType,
   E extends BaseType,
 > extends BaseType<
-  ZodMiniRecord<K['encodedZodType'], E['encodedZodType']>,
-  ZodMiniRecord<K['decodedZodType'], E['decodedZodType']>
+  zod.ZodMiniRecord<K['encodedZodType'], E['encodedZodType']>,
+  zod.ZodMiniRecord<K['decodedZodType'], E['decodedZodType']>
 > {
   static factory<
     K extends LiteralType<string | number> | EnumType | StringType,
     E extends BaseType,
   >(key: K, element: E) {
     return new RecordType<K, E>({
-      encodedZodType: record(
+      encodedZodType: zod.record(
         (key as any).encodedZodType,
         element.encodedZodType,
       ),
-      decodedZodType: record(
+      decodedZodType: zod.record(
         (key as any).decodedZodType,
         element.decodedZodType,
       ),
@@ -67,7 +66,9 @@ export class RecordType<
 
 export function keyof<T extends ObjectType>(
   type: T,
-): EnumType<core.util.ToEnum<Extract<keyof T['props']['properties'], string>>> {
+): EnumType<
+  zod.core.util.ToEnum<Extract<keyof T['props']['properties'], string>>
+> {
   return EnumType.factory(Object.keys(type.props.properties) as any)
 }
 
@@ -157,3 +158,6 @@ export function partial<
 
   return ObjectType.factory(properties)
 }
+
+export const object = ObjectType.factory
+export const record = RecordType.factory

package/src/types/string.ts

@@ -1,94 +1,78 @@
-import {
-  type core,
-  cuid,
-  cuid2,
-  e164,
-  email,
-  emoji,
-  ipv4,
-  ipv6,
-  jwt,
-  maxLength,
-  minLength,
-  nanoid,
-  regex,
-  string,
-  url,
-  uuid,
-  type ZodMiniString,
-} from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 
 import { BaseType } from './base.ts'
 
-type Check = core.CheckFn<string> | core.$ZodCheck<string>
+type Check = zod.core.CheckFn<string> | zod.core.$ZodCheck<string>
 
 export class StringType extends BaseType<
-  ZodMiniString<string>,
-  ZodMiniString<string>
+  zod.ZodMiniString<string>,
+  zod.ZodMiniString<string>
 > {
   static factory(...checks: Check[]) {
     return new StringType({
-      encodedZodType: string().check(...checks),
+      encodedZodType: zod.string().check(...checks),
       params: { checks },
     })
   }
 
   max(value: number) {
-    return StringType.factory(...this.params.checks, maxLength(value))
+    return StringType.factory(...this.params.checks, zod.maxLength(value))
   }
 
   min(value: number) {
-    return StringType.factory(...this.params.checks, minLength(value))
+    return StringType.factory(...this.params.checks, zod.minLength(value))
   }
 
   pattern(pattern: string | RegExp) {
     return StringType.factory(
       ...this.params.checks,
-      regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),
+      zod.regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),
     )
   }
 
-  email(options?: core.$ZodEmailParams) {
-    return StringType.factory(...this.params.checks, email(options))
+  email(options?: zod.core.$ZodEmailParams) {
+    return StringType.factory(...this.params.checks, zod.email(options))
   }
 
-  url(options?: core.$ZodURLParams) {
-    return StringType.factory(...this.params.checks, url(options))
+  url(options?: zod.core.$ZodURLParams) {
+    return StringType.factory(...this.params.checks, zod.url(options))
   }
 
-  ipv4(options?: core.$ZodIPv4Params) {
-    return StringType.factory(...this.params.checks, ipv4(options))
+  ipv4(options?: zod.core.$ZodIPv4Params) {
+    return StringType.factory(...this.params.checks, zod.ipv4(options))
   }
 
-  ipv6(options?: core.$ZodIPv6Params) {
-    return StringType.factory(...this.params.checks, ipv6(options))
+  ipv6(options?: zod.core.$ZodIPv6Params) {
+    return StringType.factory(...this.params.checks, zod.ipv6(options))
   }
 
-  uuid(options?: core.$ZodUUIDParams) {
-    return StringType.factory(...this.params.checks, uuid(options))
+  uuid(options?: zod.core.$ZodUUIDParams) {
+    return StringType.factory(...this.params.checks, zod.uuid(options))
   }
 
-  emoji(options?: core.$ZodEmojiParams) {
-    return StringType.factory(...this.params.checks, emoji(options))
+  emoji(options?: zod.core.$ZodEmojiParams) {
+    return StringType.factory(...this.params.checks, zod.emoji(options))
   }
 
-  nanoid(options?: core.$ZodNanoIDParams) {
-    return StringType.factory(...this.params.checks, nanoid(options))
+  nanoid(options?: zod.core.$ZodNanoIDParams) {
+    return StringType.factory(...this.params.checks, zod.nanoid(options))
   }
 
-  cuid(options?: core.$ZodCUIDParams) {
-    return StringType.factory(...this.params.checks, cuid(options))
+  cuid(options?: zod.core.$ZodCUIDParams) {
+    return StringType.factory(...this.params.checks, zod.cuid(options))
   }
 
-  cuid2(options?: core.$ZodCUID2Params) {
-    return StringType.factory(...this.params.checks, cuid2(options))
+  cuid2(options?: zod.core.$ZodCUID2Params) {
+    return StringType.factory(...this.params.checks, zod.cuid2(options))
   }
 
-  e164(options?: core.$ZodE164Params) {
-    return StringType.factory(...this.params.checks, e164(options))
+  e164(options?: zod.core.$ZodE164Params) {
+    return StringType.factory(...this.params.checks, zod.e164(options))
   }
 
-  jwt(options?: core.$ZodJWTParams) {
-    return StringType.factory(...this.params.checks, jwt(options))
+  jwt(options?: zod.core.$ZodJWTParams) {
+    return StringType.factory(...this.params.checks, zod.jwt(options))
   }
 }
+
+export const string = StringType.factory