@voidhash/mimic 0.0.1-alpha.1 → 0.0.1-alpha.10

package/src/primitives/Lazy.ts

@@ -4,10 +4,20 @@ import * as Operation from "../Operation";
 import * as OperationPath from "../OperationPath";
 import * as ProxyEnvironment from "../ProxyEnvironment";
 import * as Transform from "../Transform";
-import type { Primitive, PrimitiveInternal, AnyPrimitive, InferState, InferProxy, InferSnapshot } from "../Primitive";
+import type { Primitive, PrimitiveInternal, AnyPrimitive, InferState, InferProxy, InferSnapshot, InferSetInput, InferUpdateInput } from "../Primitive";
 import { ValidationError } from "../Primitive";
 import { runValidators } from "./shared";
 
+/**
+ * Type to infer SetInput from a lazy thunk
+ */
+export type InferLazySetInput<T extends () => AnyPrimitive> = InferSetInput<ReturnType<T>>;
+
+/**
+ * Type to infer UpdateInput from a lazy thunk
+ */
+export type InferLazyUpdateInput<T extends () => AnyPrimitive> = InferUpdateInput<ReturnType<T>>;
+
 
 /**
  * Type to infer state from a lazy thunk
@@ -25,11 +35,15 @@ export type InferLazyProxy<T extends () => AnyPrimitive> = InferProxy<ReturnType
 export type InferLazySnapshot<T extends () => AnyPrimitive> = InferSnapshot<ReturnType<T>>;
 
 export class LazyPrimitive<TThunk extends () => AnyPrimitive>
-  implements Primitive<InferLazyState<TThunk>, InferLazyProxy<TThunk>>
+  implements Primitive<InferLazyState<TThunk>, InferLazyProxy<TThunk>, false, false, InferLazySetInput<TThunk>, InferLazyUpdateInput<TThunk>>
 {
   readonly _tag = "LazyPrimitive" as const;
   readonly _State!: InferLazyState<TThunk>;
   readonly _Proxy!: InferLazyProxy<TThunk>;
+  readonly _TRequired!: false;
+  readonly _THasDefault!: false;
+  readonly TSetInput!: InferLazySetInput<TThunk>;
+  readonly TUpdateInput!: InferLazyUpdateInput<TThunk>;
 
   private readonly _thunk: TThunk;
   private _resolved: ReturnType<TThunk> | undefined;

package/src/primitives/Literal.ts

@@ -4,21 +4,25 @@ import * as Operation from "../Operation";
 import * as OperationPath from "../OperationPath";
 import * as ProxyEnvironment from "../ProxyEnvironment";
 import * as Transform from "../Transform";
-import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, Validator } from "../Primitive";
-import { ValidationError } from "../Primitive";
-import { runValidators, isCompatibleOperation } from "./shared";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, Validator, NeedsValue } from "./shared";
+import { ValidationError, runValidators, isCompatibleOperation } from "./shared";
 
 
 /** Valid literal types */
 export type LiteralValue = string | number | boolean | null;
 
-export interface LiteralProxy<T extends LiteralValue, TDefined extends boolean = false> {
+type InferSetInput<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<T, TRequired, THasDefault>
+type InferUpdateInput<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<T, TRequired, THasDefault>
+
+export interface LiteralProxy<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> {
   /** Gets the current literal value */
-  get(): MaybeUndefined<T, TDefined>;
+  get(): MaybeUndefined<T, TRequired, THasDefault>;
   /** Sets the literal value (must match the exact literal type) */
-  set(value: T): void;
+  set(value: InferSetInput<T, TRequired, THasDefault>): void;
+  /** This is the same as set. Updates the literal value, generating a literal.set operation */
+  update(value: InferUpdateInput<T, TRequired, THasDefault>): void;
   /** Returns a readonly snapshot of the literal value for rendering */
-  toSnapshot(): MaybeUndefined<T, TDefined>;
+  toSnapshot(): MaybeUndefined<T, TRequired, THasDefault>;
 }
 
 interface LiteralPrimitiveSchema<T extends LiteralValue> {
@@ -27,10 +31,14 @@ interface LiteralPrimitiveSchema<T extends LiteralValue> {
   readonly literal: T;
 }
 
-export class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean = false> implements Primitive<T, LiteralProxy<T, TDefined>> {
+export class LiteralPrimitive<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<T, LiteralProxy<T, TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<T, TRequired, THasDefault>, InferUpdateInput<T, TRequired, THasDefault>> {
   readonly _tag = "LiteralPrimitive" as const;
   readonly _State!: T;
-  readonly _Proxy!: LiteralProxy<T, TDefined>;
+  readonly _Proxy!: LiteralProxy<T, TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
+  readonly _THasDefault!: THasDefault;
+  readonly TUpdateInput!: InferUpdateInput<T, TRequired, THasDefault>;
+  readonly TSetInput!: InferSetInput<T, TRequired, THasDefault>;
 
   private readonly _schema: LiteralPrimitiveSchema<T>;
 
@@ -48,7 +56,7 @@ export class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean =
   }
 
   /** Mark this literal as required */
-  required(): LiteralPrimitive<T, true> {
+  required(): LiteralPrimitive<T, true, THasDefault> {
     return new LiteralPrimitive({
       ...this._schema,
       required: true,
@@ -56,7 +64,7 @@ export class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean =
   }
 
   /** Set a default value for this literal */
-  default(defaultValue: T): LiteralPrimitive<T, true> {
+  default(defaultValue: T): LiteralPrimitive<T, TRequired, true> {
     return new LiteralPrimitive({
       ...this._schema,
       defaultValue,
@@ -68,27 +76,32 @@ export class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean =
     return this._schema.literal;
   }
 
-  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TDefined>> = {
-    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): LiteralProxy<T, TDefined> => {
+  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TRequired, THasDefault>> = {
+    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): LiteralProxy<T, TRequired, THasDefault> => {
       const defaultValue = this._schema.defaultValue;
       return {
-        get: (): MaybeUndefined<T, TDefined> => {
+        get: (): MaybeUndefined<T, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as T | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<T, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<T, TRequired, THasDefault>;
+        },
+        set: (value: InferSetInput<T, TRequired, THasDefault>) => {
+          env.addOperation(
+            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
+          );
         },
-        set: (value: T) => {
+        update: (value: InferUpdateInput<T, TRequired, THasDefault>) => {
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
           );
         },
-        toSnapshot: (): MaybeUndefined<T, TDefined> => {
+        toSnapshot: (): MaybeUndefined<T, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as T | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<T, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<T, TRequired, THasDefault>;
         },
       };
     },
 
-    applyOperation: (state: T | undefined, operation: Operation.Operation<any, any, any>): T => {
+    applyOperation: (_state: T | undefined, operation: Operation.Operation<any, any, any>): T => {
       if (operation.kind !== "literal.set") {
         throw new ValidationError(`LiteralPrimitive cannot apply operation of kind: ${operation.kind}`);
       }
@@ -123,6 +136,6 @@ export class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean =
 }
 
 /** Creates a new LiteralPrimitive with the given literal value */
-export const Literal = <T extends LiteralValue>(literal: T): LiteralPrimitive<T, false> =>
+export const Literal = <T extends LiteralValue>(literal: T): LiteralPrimitive<T, false, false> =>
   new LiteralPrimitive({ required: false, defaultValue: undefined, literal });
 

package/src/primitives/Number.ts

@@ -4,18 +4,22 @@ import * as Operation from "../Operation";
 import * as OperationPath from "../OperationPath";
 import * as ProxyEnvironment from "../ProxyEnvironment";
 import * as Transform from "../Transform";
-import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, Validator } from "../Primitive";
-import { ValidationError } from "../Primitive";
-import { runValidators, isCompatibleOperation } from "./shared";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, Validator, NeedsValue } from "./shared";
+import { ValidationError, runValidators, isCompatibleOperation } from "./shared";
 
 
-export interface NumberProxy<TDefined extends boolean = false> {
+type InferSetInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<number, TRequired, THasDefault>
+type InferUpdateInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<number, TRequired, THasDefault>
+
+export interface NumberProxy<TRequired extends boolean = false, THasDefault extends boolean = false> {
   /** Gets the current number value */
-  get(): MaybeUndefined<number, TDefined>;
+  get(): MaybeUndefined<number, TRequired, THasDefault>;
   /** Sets the number value, generating a number.set operation */
-  set(value: number): void;
+  set(value: InferSetInput<TRequired, THasDefault>): void;
+  /** This is the same as set. Updates the number value, generating a number.set operation */
+  update(value: InferUpdateInput<TRequired, THasDefault>): void;
   /** Returns a readonly snapshot of the number value for rendering */
-  toSnapshot(): MaybeUndefined<number, TDefined>;
+  toSnapshot(): MaybeUndefined<number, TRequired, THasDefault>;
 }
 
 interface NumberPrimitiveSchema {
@@ -24,10 +28,14 @@ interface NumberPrimitiveSchema {
   readonly validators: readonly Validator<number>[];
 }
 
-export class NumberPrimitive<TDefined extends boolean = false> implements Primitive<number, NumberProxy<TDefined>> {
+export class NumberPrimitive<TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<number, NumberProxy<TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<TRequired, THasDefault>, InferUpdateInput<TRequired, THasDefault>> {
   readonly _tag = "NumberPrimitive" as const;
   readonly _State!: number;
-  readonly _Proxy!: NumberProxy<TDefined>;
+  readonly _Proxy!: NumberProxy<TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
+  readonly _THasDefault!: THasDefault;
+  readonly TUpdateInput!: InferUpdateInput<TRequired, THasDefault>;
+  readonly TSetInput!: InferSetInput<TRequired, THasDefault>;
 
   private readonly _schema: NumberPrimitiveSchema;
 
@@ -45,7 +53,7 @@ export class NumberPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Mark this number as required */
-  required(): NumberPrimitive<true> {
+  required(): NumberPrimitive<true, THasDefault> {
     return new NumberPrimitive({
       ...this._schema,
       required: true,
@@ -53,7 +61,7 @@ export class NumberPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Set a default value for this number */
-  default(defaultValue: number): NumberPrimitive<true> {
+  default(defaultValue: number): NumberPrimitive<TRequired, true> {
     return new NumberPrimitive({
       ...this._schema,
       defaultValue,
@@ -61,7 +69,7 @@ export class NumberPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Add a custom validation rule */
-  refine(fn: (value: number) => boolean, message: string): NumberPrimitive<TDefined> {
+  refine(fn: (value: number) => boolean, message: string): NumberPrimitive<TRequired, THasDefault> {
     return new NumberPrimitive({
       ...this._schema,
       validators: [...this._schema.validators, { validate: fn, message }],
@@ -69,7 +77,7 @@ export class NumberPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Minimum value (inclusive) */
-  min(value: number): NumberPrimitive<TDefined> {
+  min(value: number): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v >= value,
       `Number must be at least ${value}`
@@ -77,7 +85,7 @@ export class NumberPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Maximum value (inclusive) */
-  max(value: number): NumberPrimitive<TDefined> {
+  max(value: number): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v <= value,
       `Number must be at most ${value}`
@@ -85,7 +93,7 @@ export class NumberPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Must be positive (> 0) */
-  positive(): NumberPrimitive<TDefined> {
+  positive(): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v > 0,
       "Number must be positive"
@@ -93,7 +101,7 @@ export class NumberPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Must be negative (< 0) */
-  negative(): NumberPrimitive<TDefined> {
+  negative(): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v < 0,
       "Number must be negative"
@@ -101,34 +109,39 @@ export class NumberPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Must be an integer */
-  int(): NumberPrimitive<TDefined> {
+  int(): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => globalThis.Number.isInteger(v),
       "Number must be an integer"
     );
   }
 
-  readonly _internal: PrimitiveInternal<number, NumberProxy<TDefined>> = {
-    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): NumberProxy<TDefined> => {
+  readonly _internal: PrimitiveInternal<number, NumberProxy<TRequired, THasDefault>> = {
+    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): NumberProxy<TRequired, THasDefault> => {
       const defaultValue = this._schema.defaultValue;
       return {
-        get: (): MaybeUndefined<number, TDefined> => {
+        get: (): MaybeUndefined<number, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as number | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<number, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<number, TRequired, THasDefault>;
+        },
+        set: (value: InferSetInput<TRequired, THasDefault>) => {
+          env.addOperation(
+            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
+          );
         },
-        set: (value: number) => {
+        update: (value: InferUpdateInput<TRequired, THasDefault>) => {
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
           );
         },
-        toSnapshot: (): MaybeUndefined<number, TDefined> => {
+        toSnapshot: (): MaybeUndefined<number, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as number | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<number, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<number, TRequired, THasDefault>;
         },
       };
     },
 
-    applyOperation: (state: number | undefined, operation: Operation.Operation<any, any, any>): number => {
+    applyOperation: (_state: number | undefined, operation: Operation.Operation<any, any, any>): number => {
       if (operation.kind !== "number.set") {
         throw new ValidationError(`NumberPrimitive cannot apply operation of kind: ${operation.kind}`);
       }
@@ -164,6 +177,6 @@ export class NumberPrimitive<TDefined extends boolean = false> implements Primit
 }
 
 /** Creates a new NumberPrimitive */
-export const Number = (): NumberPrimitive<false> =>
+export const Number = (): NumberPrimitive<false, false> =>
   new NumberPrimitive({ required: false, defaultValue: undefined, validators: [] });
 

package/src/primitives/String.ts

@@ -4,20 +4,26 @@ import * as Operation from "../Operation";
 import * as OperationPath from "../OperationPath";
 import * as ProxyEnvironment from "../ProxyEnvironment";
 import * as Transform from "../Transform";
-import type { Primitive, PrimitiveInternal, MaybeUndefined, Validator } from "./shared";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, Validator, NeedsValue } from "./shared";
 import { runValidators, isCompatibleOperation, ValidationError } from "./shared";
 
+
+type InferSetInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<string, TRequired, THasDefault>
+type InferUpdateInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<string, TRequired, THasDefault>
+
 // =============================================================================
 // String Primitive
 // =============================================================================
 
-export interface StringProxy<TDefined extends boolean = false> {
+export interface StringProxy<TRequired extends boolean = false, THasDefault extends boolean = false> {
   /** Gets the current string value */
-  get(): MaybeUndefined<string, TDefined>;
+  get(): MaybeUndefined<string, TRequired, THasDefault>;
   /** Sets the string value, generating a string.set operation */
-  set(value: string): void;
+  set(value: InferSetInput<TRequired, THasDefault>): void;
+  /** This is the same as set. Updates the string value, generating a string.set operation */
+  update(value: InferUpdateInput<TRequired, THasDefault>): void;
   /** Returns a readonly snapshot of the string value for rendering */
-  toSnapshot(): MaybeUndefined<string, TDefined>;
+  toSnapshot(): MaybeUndefined<string, TRequired, THasDefault>;
 }
 
 interface StringPrimitiveSchema {
@@ -26,10 +32,14 @@ interface StringPrimitiveSchema {
   readonly validators: readonly Validator<string>[];
 }
 
-export class StringPrimitive<TDefined extends boolean = false> implements Primitive<string, StringProxy<TDefined>> {
+export class StringPrimitive<TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<string, StringProxy<TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<TRequired, THasDefault>, InferUpdateInput<TRequired, THasDefault>> {
   readonly _tag = "StringPrimitive" as const;
   readonly _State!: string;
-  readonly _Proxy!: StringProxy<TDefined>;
+  readonly _Proxy!: StringProxy<TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
+  readonly _THasDefault!: THasDefault;
+  readonly TUpdateInput!: InferUpdateInput<TRequired, THasDefault>;
+  readonly TSetInput!: InferSetInput<TRequired, THasDefault>;
 
   private readonly _schema: StringPrimitiveSchema;
 
@@ -47,7 +57,7 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Mark this string as required */
-  required(): StringPrimitive<true> {
+  required(): StringPrimitive<true, THasDefault> {
     return new StringPrimitive({
       ...this._schema,
       required: true,
@@ -55,7 +65,7 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Set a default value for this string */
-  default(defaultValue: string): StringPrimitive<true> {
+  default(defaultValue: string): StringPrimitive<TRequired, true> {
     return new StringPrimitive({
       ...this._schema,
       defaultValue,
@@ -63,7 +73,7 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Add a custom validation rule */
-  refine(fn: (value: string) => boolean, message: string): StringPrimitive<TDefined> {
+  refine(fn: (value: string) => boolean, message: string): StringPrimitive<TRequired, THasDefault> {
     return new StringPrimitive({
       ...this._schema,
       validators: [...this._schema.validators, { validate: fn, message }],
@@ -71,7 +81,7 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Minimum string length */
-  min(length: number): StringPrimitive<TDefined> {
+  min(length: number): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v.length >= length,
       `String must be at least ${length} characters`
@@ -79,7 +89,7 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Maximum string length */
-  max(length: number): StringPrimitive<TDefined> {
+  max(length: number): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v.length <= length,
       `String must be at most ${length} characters`
@@ -87,7 +97,7 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Exact string length */
-  length(exact: number): StringPrimitive<TDefined> {
+  length(exact: number): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v.length === exact,
       `String must be exactly ${exact} characters`
@@ -95,7 +105,7 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Match a regex pattern */
-  regex(pattern: RegExp, message?: string): StringPrimitive<TDefined> {
+  regex(pattern: RegExp, message?: string): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => pattern.test(v),
       message ?? `String must match pattern ${pattern}`
@@ -103,7 +113,7 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Validate as email format */
-  email(): StringPrimitive<TDefined> {
+  email(): StringPrimitive<TRequired, THasDefault> {
     // Simple email regex - covers most common cases
     const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
     return this.refine(
@@ -113,7 +123,7 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
   }
 
   /** Validate as URL format */
-  url(): StringPrimitive<TDefined> {
+  url(): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => {
         try {
@@ -127,27 +137,32 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
     );
   }
 
-  readonly _internal: PrimitiveInternal<string, StringProxy<TDefined>> = {
-    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): StringProxy<TDefined> => {
+  readonly _internal: PrimitiveInternal<string, StringProxy<TRequired, THasDefault>> = {
+    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): StringProxy<TRequired, THasDefault> => {
       const defaultValue = this._schema.defaultValue;
       return {
-        get: (): MaybeUndefined<string, TDefined> => {
+        get: (): MaybeUndefined<string, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as string | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<string, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<string, TRequired, THasDefault>;
+        },
+        set: (value: InferSetInput<TRequired, THasDefault>) => {
+          env.addOperation(
+            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
+          );
         },
-        set: (value: string) => {
+        update: (value: InferUpdateInput<TRequired, THasDefault>) => {
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
           );
         },
-        toSnapshot: (): MaybeUndefined<string, TDefined> => {
+        toSnapshot: (): MaybeUndefined<string, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as string | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<string, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<string, TRequired, THasDefault>;
         },
       };
     },
 
-    applyOperation: (state: string | undefined, operation: Operation.Operation<any, any, any>): string => {
+    applyOperation: (_state: string | undefined, operation: Operation.Operation<any, any, any>): string => {
       if (!isCompatibleOperation(operation, this._opDefinitions)) {
         throw new ValidationError(`StringPrimitive cannot apply operation of kind: ${operation.kind}`);
       }
@@ -184,6 +199,6 @@ export class StringPrimitive<TDefined extends boolean = false> implements Primit
 }
 
 /** Creates a new StringPrimitive */
-export const String = (): StringPrimitive<false> =>
+export const String = (): StringPrimitive<false, false> =>
   new StringPrimitive({ required: false, defaultValue: undefined, validators: [] });