@strictly/define 0.0.7 → 0.0.9

package/.out/types/builders.d.ts

@@ -1,4 +1,5 @@
 import { type IsFieldReadonly } from '@strictly/base';
+import { type Validator } from 'validation/validator';
 import { type ObjectFieldKey, type RecordKeyType, type Type, type TypeDef, TypeDefType, type UnionKey } from './definitions';
 import { type TypeOfType } from './type_of_type';
 import { type Rule, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingType, type ValidatingTypeDef, type ValidatingUnionTypeDef } from './validating_definitions';
@@ -7,9 +8,8 @@ import { type ValueOfType, type ValueOfTypeDef } from './value_of_type';
 declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
     readonly definition: T;
     constructor(definition: T);
-    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
-    required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>;
-    required<RequiredError>(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>;
+    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
+    required(): TypeDefBuilder<T>;
     readonly(): TypeDefBuilder<T>;
     get _type(): TypeOfType<Type<T>>;
     get narrow(): ValidatingType<T>;

package/.out/types/builders.js

@@ -1,3 +1,4 @@
+import { isAnnotatedValidator, mergeAnnotations, validate, } from 'validation/validator';
 import { TypeDefType, } from './definitions';
 import { typeOfType, } from './type_of_type';
 function emptyRule() {
@@ -13,22 +14,19 @@ class TypeDefBuilder {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         {
             ...this.definition,
+            ...(isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null, null), this.definition) : {}),
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             rule: (value) => {
-                return this.definition.rule(value) || rule(value);
+                return this.definition.rule(value) ?? validate(rule, value, null, null);
             },
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         });
     }
-    required(rule) {
+    required() {
         return new TypeDefBuilder(
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         {
             ...this.definition,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            rule: (v) => {
-                return this.definition.rule(v) || rule?.(v);
-            },
             required: true,
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         });

package/.out/validation/validator.d.ts

@@ -1,21 +1,23 @@
 import { type Simplify } from 'type-fest';
+export type Annotations = {
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
 export type FunctionalValidator<V = any, E = any, ValuePath extends string = any, Context = any> = (v: V, valuePath: ValuePath, context: Context) => E | null;
 export type AnnotatedValidator<V = any, E = any, ValuePath extends string = any, Context = any> = {
     readonly validate: (v: V, valuePath: ValuePath, context: Context) => E | null;
-    readonly annotations: (valuePath: ValuePath, context: Context) => {
-        readonly required: boolean;
-        readonly readonly: boolean;
-    };
+    readonly annotations: (valuePath: ValuePath, context: Context) => Annotations;
 };
 export type Validator<V = any, E = any, ValuePath extends string = any, Context = any> = FunctionalValidator<V, E, ValuePath, Context> | AnnotatedValidator<V, E, ValuePath, Context>;
 export type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E : never;
 export type ValidationError<Type extends string, Data = {}> = Simplify<{
     type: Type;
 } & Data>;
-export declare function isFunctionalValidator(v: Validator): v is FunctionalValidator;
-export declare function isAnnotatedValidator(v: Validator): v is AnnotatedValidator;
+export declare function isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
+export declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
 export declare function validate<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, v: V, valuePath: ValuePath, context: Context): E | null;
-export declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): {
-    readonly required: boolean;
-    readonly readonly: boolean;
+export declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): Annotations;
+export declare function mergeAnnotations(a1: Annotations, a2: Annotations): {
+    readonly: boolean;
+    required: boolean;
 };

package/.out/validation/validator.js

@@ -9,7 +9,6 @@ export function validate(validator, v, valuePath, context) {
         return validator.validate(v, valuePath, context);
     }
     else {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return validator(v, valuePath, context);
     }
 }
@@ -24,3 +23,9 @@ export function annotations(validator, valuePath, context) {
         };
     }
 }
+export function mergeAnnotations(a1, a2) {
+    return {
+        readonly: a1.readonly || a2.readonly,
+        required: a1.required || a2.required,
+    };
+}

package/.out/validation/validators/defined_validator.d.ts

@@ -1,5 +1,5 @@
 import { type AnnotatedValidator } from 'validation/validator';
-export declare class DefinedValidator<V, E, ValuePath extends string, Context> implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context> {
+export declare class DefinedValidator<V, E> implements AnnotatedValidator<V | null | undefined, E, never, never> {
     private readonly error;
     constructor(error: E);
     validate(v: V | null | undefined): E | null;

package/.out/validation/validators/minimum_string_length_validator.d.ts

@@ -5,7 +5,7 @@ export type MinimumStringLengthValidationError = {
     receivedLength: number;
     minimumLength: number;
 };
-export declare class MinimumStringLengthValidator<ValuePath extends string, Context> implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context> {
+export declare class MinimumStringLengthValidator implements AnnotatedValidator<string, MinimumStringLengthValidationError, never, never> {
     private readonly minimumLength;
     constructor(minimumLength: number);
     validate(value: string): MinimumStringLengthValidationError | null;

package/.out/validation/validators/minimum_string_length_validator.js

@@ -16,7 +16,7 @@ export class MinimumStringLengthValidator {
     }
     annotations() {
         return {
-            required: true,
+            required: this.minimumLength > 0,
             readonly: false,
         };
     }

package/.out/validation/validators/optional_validator_proxy.d.ts

@@ -0,0 +1,13 @@
+import { type AnnotatedValidator } from 'validation/validator';
+export declare class OptionalValidatorProxy<V, V1 extends V, E, ValuePath extends string, Context> implements AnnotatedValidator<V, E, ValuePath, Context> {
+    private readonly proxied;
+    private readonly isRequired;
+    static createNullable<V, E, ValuePath extends string, Context>(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>): OptionalValidatorProxy<V, NonNullable<V>, E, ValuePath, Context>;
+    static createNullableOrEmptyString<V extends string | null | undefined, E, ValuePath extends string, Context>(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>): OptionalValidatorProxy<V, NonNullable<V>, E, ValuePath, Context>;
+    constructor(proxied: AnnotatedValidator<V1, E, ValuePath, Context>, isRequired: (v: V) => v is V1);
+    validate(v: V, valuePath: ValuePath, context: Context): E | null;
+    annotations(valuePath: ValuePath, context: Context): {
+        required: boolean;
+        readonly: boolean;
+    };
+}

package/.out/validation/validators/optional_validator_proxy.js

@@ -0,0 +1,26 @@
+export class OptionalValidatorProxy {
+    proxied;
+    isRequired;
+    static createNullable(proxied) {
+        return new OptionalValidatorProxy(proxied, (v) => v != null);
+    }
+    static createNullableOrEmptyString(proxied) {
+        return new OptionalValidatorProxy(proxied, (v) => v != null && v !== '');
+    }
+    constructor(proxied, isRequired) {
+        this.proxied = proxied;
+        this.isRequired = isRequired;
+    }
+    validate(v, valuePath, context) {
+        if (this.isRequired(v)) {
+            return this.proxied.validate(v, valuePath, context);
+        }
+        return null;
+    }
+    annotations(valuePath, context) {
+        return {
+            ...this.proxied.annotations(valuePath, context),
+            required: false,
+        };
+    }
+}

package/.out/validation/validators/regexp_validator.d.ts

@@ -0,0 +1,29 @@
+import { type AnnotatedValidator } from 'validation/validator';
+export declare const RegexpValidationErrorType = "regexp";
+export type RegexpValidationError<Intent extends string> = {
+    type: typeof RegexpValidationErrorType;
+    intent: Intent;
+};
+export declare class RegexpValidator<Intent extends string> implements AnnotatedValidator<string, RegexpValidationError<Intent>, never, never> {
+    private readonly regexp;
+    private readonly intent;
+    /**
+     * Extremely permissive email validator
+     */
+    static readonly email: RegexpValidator<"email">;
+    /**
+     * Extremely permissive phone number validator
+     */
+    static readonly phone: RegexpValidator<"phone">;
+    private readonly negate;
+    private readonly required;
+    constructor(regexp: RegExp, intent: Intent, { negate, required, }?: {
+        negate?: boolean;
+        required?: boolean;
+    });
+    validate(value: string): RegexpValidationError<Intent> | null;
+    annotations(): {
+        required: boolean;
+        readonly: boolean;
+    };
+}

package/.out/validation/validators/regexp_validator.js

@@ -0,0 +1,37 @@
+export const RegexpValidationErrorType = 'regexp';
+export class RegexpValidator {
+    regexp;
+    intent;
+    /**
+     * Extremely permissive email validator
+     */
+    static email = new RegexpValidator(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, 'email');
+    /**
+     * Extremely permissive phone number validator
+     */
+    static phone = new RegexpValidator(/^(\+\d{1,4}[\s]*)?(((\([\d\s-]{1,6}\))|\d)[\s-]*){3,14}(\d|(\(\d+\)))$/, 'phone');
+    negate;
+    required;
+    constructor(regexp, intent, { negate = false, required = false, } = {}) {
+        this.regexp = regexp;
+        this.intent = intent;
+        this.negate = negate;
+        this.required = required;
+    }
+    validate(value) {
+        const passes = this.regexp.test(value);
+        if (!passes && !this.negate || passes && this.negate) {
+            return {
+                type: RegexpValidationErrorType,
+                intent: this.intent,
+            };
+        }
+        return null;
+    }
+    annotations() {
+        return {
+            required: this.required,
+            readonly: false,
+        };
+    }
+}

package/.out/validation/validators/specs/minimum_string_length_validator.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/validation/validators/specs/minimum_string_length_validator.tests.js

@@ -0,0 +1,69 @@
+import { MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, } from 'validation/validators/minimum_string_length_validator';
+describe('MinimumStringLengthValidator', () => {
+    describe('required', () => {
+        it.each([
+            1,
+            2,
+            100,
+        ])('is required when the string length is %s', (minimumLength) => {
+            const validator = new MinimumStringLengthValidator(minimumLength);
+            expect(validator.annotations().required).toBeTruthy();
+        });
+        it('is not required when the string length is zero', () => {
+            const validator = new MinimumStringLengthValidator(0);
+            expect(validator.annotations().required).toBeFalsy();
+        });
+    });
+    describe('validation', () => {
+        it.each([
+            [
+                1,
+                'a',
+            ],
+            [
+                2,
+                'asdf',
+            ],
+            [
+                0,
+                '',
+            ],
+            [
+                20,
+                '12345678901234567890',
+            ],
+        ])('passes validation with minimum length %s and value "%s"', (minimumLength, value) => {
+            const validator = new MinimumStringLengthValidator(minimumLength);
+            expect(validator.validate(value)).toBeNull();
+        });
+        it.each([
+            [
+                1,
+                '',
+                0,
+            ],
+            [
+                2,
+                'a',
+                1,
+            ],
+            [
+                20,
+                '1234567890123456789',
+                19,
+            ],
+            [
+                100,
+                '',
+                0,
+            ],
+        ])('fails validation with minimum length %s and value "%s', (minimumLength, value, receivedLength) => {
+            const validator = new MinimumStringLengthValidator(minimumLength);
+            expect(validator.validate(value)).toEqual({
+                type: MinimumStringLengthValidationErrorType,
+                minimumLength,
+                receivedLength,
+            });
+        });
+    });
+});

package/.out/validation/validators/specs/regexp_validator.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/validation/validators/specs/regexp_validator.tests.js

@@ -0,0 +1,98 @@
+import { RegexpValidationErrorType, RegexpValidator, } from 'validation/validators/regexp_validator';
+describe('RegexpValidator', () => {
+    describe('phone', () => {
+        it.each([
+            '0403545000',
+            '+12 (1800) 000 000',
+            '1-2-3-4-5-6',
+            '+1 394 3234 000 (2)',
+            '1234',
+        ])('accepts "%s"', (phoneNumber) => {
+            expect(RegexpValidator.phone.validate(phoneNumber)).toBeNull();
+        });
+        it.each([
+            '',
+            'ABC',
+            '1',
+            ' 0412345678',
+            '----1245456',
+            '1      2',
+            '234234+234',
+        ])('rejects "%s"', (phoneNumber) => {
+            expect(RegexpValidator.phone.validate(phoneNumber)).toEqual({
+                type: RegexpValidationErrorType,
+                intent: 'phone',
+            });
+        });
+    });
+    describe('email', () => {
+        it.each([
+            'x@y.z',
+            'support@company.com',
+            '...@......',
+            '1234@3454.23',
+        ])('accepts "%s"', (email) => {
+            expect(RegexpValidator.email.validate(email)).toBeNull();
+        });
+        it.each([
+            '',
+            '@@@@',
+            'email',
+            '@bee.com',
+            'aaa@bbb',
+            'a a@b b.c c',
+        ])('rejects "%s"', (email) => {
+            expect(RegexpValidator.email.validate(email)).toEqual({
+                type: RegexpValidationErrorType,
+                intent: 'email',
+            });
+        });
+    });
+    describe('required', () => {
+        it.each([
+            true,
+            false,
+        ])('exposes required %s', (required) => {
+            const validator = new RegexpValidator(/a/, 'test', {
+                required,
+            });
+            expect(validator.annotations().required).toBe(required);
+        });
+    });
+    describe('general', () => {
+        // not here to test if regexp works
+        it.each([
+            [
+                '^a$',
+                'a',
+            ],
+            [
+                '^\\w+$',
+                'asdf',
+            ],
+        ])('passes validation with regexp "%s" and value "%s"', (regexpString, value) => {
+            const regexp = new RegExp(regexpString);
+            const validator = new RegexpValidator(regexp, 'test');
+            expect(validator.validate(value)).toBeNull();
+        });
+        it.each([
+            [
+                '^$',
+                'something',
+                'empty',
+            ],
+            [
+                '^\\w+$',
+                '',
+                'non-empty',
+            ],
+        ])('fails validation with regexp "%s" and value "%s', (regexpString, value, intent) => {
+            const regexp = new RegExp(regexpString);
+            const validator = new RegexpValidator(regexp, intent);
+            expect(validator.validate(value)).toEqual({
+                type: RegexpValidationErrorType,
+                intent,
+            });
+        });
+    });
+});

package/.turbo/turbo-build.log

@@ -7,12 +7,12 @@ $ tsup
 CLI Target: esnext
 CJS Build start
 ESM Build start
-ESM dist/index.js 24.72 KB
-ESM ⚡️ Build success in 65ms
-CJS dist/index.cjs 26.92 KB
-CJS ⚡️ Build success in 66ms
+CJS dist/index.cjs 29.06 KB
+CJS ⚡️ Build success in 62ms
+ESM dist/index.js 26.67 KB
+ESM ⚡️ Build success in 63ms
 DTS Build start
-DTS ⚡️ Build success in 5516ms
-DTS dist/index.d.cts 38.05 KB
-DTS dist/index.d.ts  38.05 KB
-Done in 6.38s.
+DTS ⚡️ Build success in 5551ms
+DTS dist/index.d.cts 40.10 KB
+DTS dist/index.d.ts  40.10 KB
+Done in 6.43s.

package/.turbo/turbo-check-types.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ tsc
-Done in 4.94s.
+Done in 4.85s.

package/dist/index.cjs

@@ -23,6 +23,9 @@ __export(index_exports, {
   DefinedValidator: () => DefinedValidator,
   MinimumStringLengthValidationErrorType: () => MinimumStringLengthValidationErrorType,
   MinimumStringLengthValidator: () => MinimumStringLengthValidator,
+  OptionalValidatorProxy: () => OptionalValidatorProxy,
+  RegexpValidationErrorType: () => RegexpValidationErrorType,
+  RegexpValidator: () => RegexpValidator,
   TypeDefType: () => TypeDefType,
   annotations: () => annotations,
   booleanType: () => booleanType,
@@ -40,6 +43,7 @@ __export(index_exports, {
   jsonPathPop: () => jsonPathPop,
   list: () => list,
   literal: () => literal,
+  mergeAnnotations: () => mergeAnnotations,
   mobxCopy: () => mobxCopy,
   nullType: () => nullType,
   nullable: () => nullable,
@@ -430,7 +434,7 @@ function flattenTypeTo({ definition }, mapper2) {
   return (0, import_base4.reduce)(
     typeDefs,
     function(acc, key, typeDef) {
-      acc[key] = mapper2(typeDef);
+      acc[key] = mapper2(typeDef, key);
       return acc;
     },
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -671,6 +675,37 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
   }
 }
 
+// validation/validator.ts
+function isFunctionalValidator(v) {
+  return typeof v === "function";
+}
+function isAnnotatedValidator(v) {
+  return typeof v !== "function";
+}
+function validate(validator, v, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.validate(v, valuePath, context);
+  } else {
+    return validator(v, valuePath, context);
+  }
+}
+function annotations(validator, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.annotations(valuePath, context);
+  } else {
+    return {
+      required: false,
+      readonly: false
+    };
+  }
+}
+function mergeAnnotations(a1, a2) {
+  return {
+    readonly: a1.readonly || a2.readonly,
+    required: a1.required || a2.required
+  };
+}
+
 // types/type_of_type.ts
 var import_base6 = require("@strictly/base");
 function typeOfType({ definition }) {
@@ -761,23 +796,20 @@ var TypeDefBuilder = class _TypeDefBuilder {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
+        ...isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null, null), this.definition) : {},
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         rule: (value) => {
-          return this.definition.rule(value) || rule(value);
+          return this.definition.rule(value) ?? validate(rule, value, null, null);
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       }
     );
   }
-  required(rule) {
+  required() {
     return new _TypeDefBuilder(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        rule: (v) => {
-          return this.definition.rule(v) || rule?.(v);
-        },
         required: true
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       }
@@ -982,31 +1014,6 @@ function union(discriminator) {
   );
 }
 
-// validation/validator.ts
-function isFunctionalValidator(v) {
-  return typeof v === "function";
-}
-function isAnnotatedValidator(v) {
-  return typeof v !== "function";
-}
-function validate(validator, v, valuePath, context) {
-  if (isAnnotatedValidator(validator)) {
-    return validator.validate(v, valuePath, context);
-  } else {
-    return validator(v, valuePath, context);
-  }
-}
-function annotations(validator, valuePath, context) {
-  if (isAnnotatedValidator(validator)) {
-    return validator.annotations(valuePath, context);
-  } else {
-    return {
-      required: false,
-      readonly: false
-    };
-  }
-}
-
 // validation/validators/defined_validator.ts
 var DefinedValidator = class {
   constructor(error) {
@@ -1044,7 +1051,76 @@ var MinimumStringLengthValidator = class {
   }
   annotations() {
     return {
-      required: true,
+      required: this.minimumLength > 0,
+      readonly: false
+    };
+  }
+};
+
+// validation/validators/optional_validator_proxy.ts
+var OptionalValidatorProxy = class _OptionalValidatorProxy {
+  constructor(proxied, isRequired) {
+    this.proxied = proxied;
+    this.isRequired = isRequired;
+  }
+  static createNullable(proxied) {
+    return new _OptionalValidatorProxy(proxied, (v) => v != null);
+  }
+  static createNullableOrEmptyString(proxied) {
+    return new _OptionalValidatorProxy(proxied, (v) => v != null && v !== "");
+  }
+  validate(v, valuePath, context) {
+    if (this.isRequired(v)) {
+      return this.proxied.validate(v, valuePath, context);
+    }
+    return null;
+  }
+  annotations(valuePath, context) {
+    return {
+      ...this.proxied.annotations(valuePath, context),
+      required: false
+    };
+  }
+};
+
+// validation/validators/regexp_validator.ts
+var RegexpValidationErrorType = "regexp";
+var RegexpValidator = class _RegexpValidator {
+  constructor(regexp, intent, {
+    negate = false,
+    required = false
+  } = {}) {
+    this.regexp = regexp;
+    this.intent = intent;
+    this.negate = negate;
+    this.required = required;
+  }
+  /**
+   * Extremely permissive email validator
+   */
+  static email = new _RegexpValidator(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, "email");
+  /**
+   * Extremely permissive phone number validator
+   */
+  static phone = new _RegexpValidator(
+    /^(\+\d{1,4}[\s]*)?(((\([\d\s-]{1,6}\))|\d)[\s-]*){3,14}(\d|(\(\d+\)))$/,
+    "phone"
+  );
+  negate;
+  required;
+  validate(value) {
+    const passes = this.regexp.test(value);
+    if (!passes && !this.negate || passes && this.negate) {
+      return {
+        type: RegexpValidationErrorType,
+        intent: this.intent
+      };
+    }
+    return null;
+  }
+  annotations() {
+    return {
+      required: this.required,
       readonly: false
     };
   }
@@ -1054,6 +1130,9 @@ var MinimumStringLengthValidator = class {
   DefinedValidator,
   MinimumStringLengthValidationErrorType,
   MinimumStringLengthValidator,
+  OptionalValidatorProxy,
+  RegexpValidationErrorType,
+  RegexpValidator,
   TypeDefType,
   annotations,
   booleanType,
@@ -1071,6 +1150,7 @@ var MinimumStringLengthValidator = class {
   jsonPathPop,
   list,
   literal,
+  mergeAnnotations,
   mobxCopy,
   nullType,
   nullable,