diff --git a/src/utils/animations/__tests__/animation.ts b/src/utils/animations/__tests__/animation.ts
index a10e4e2..b3688a4 100644
--- a/src/utils/animations/__tests__/animation.ts
+++ b/src/utils/animations/__tests__/animation.ts
@@ -24,6 +24,11 @@ describe('animation', () => {
     expect(result).toEqual({ animation: 'a' });
   });
 
+  it('should use an interface which marks `animation` as optional', () => {
+    const result = animation<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = animation<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/animations/__tests__/animationDelay.ts b/src/utils/animations/__tests__/animationDelay.ts
index b2ecd18..ff8d7a9 100644
--- a/src/utils/animations/__tests__/animationDelay.ts
+++ b/src/utils/animations/__tests__/animationDelay.ts
@@ -24,6 +24,11 @@ describe('animationDelay', () => {
     expect(result).toEqual({ animationDelay: 'a' });
   });
 
+  it('should use an interface which marks `animationDelay` as optional', () => {
+    const result = animationDelay<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = animationDelay<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/animations/__tests__/animationDirection.ts b/src/utils/animations/__tests__/animationDirection.ts
index dff1dad..4f6000c 100644
--- a/src/utils/animations/__tests__/animationDirection.ts
+++ b/src/utils/animations/__tests__/animationDirection.ts
@@ -24,6 +24,11 @@ describe('animationDirection', () => {
     expect(result).toEqual({ animationDirection: 'a' });
   });
 
+  it('should use an interface which marks `animationDirection` as optional', () => {
+    const result = animationDirection<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = animationDirection<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/animations/__tests__/animationDuration.ts b/src/utils/animations/__tests__/animationDuration.ts
index edcb9c1..6372ccb 100644
--- a/src/utils/animations/__tests__/animationDuration.ts
+++ b/src/utils/animations/__tests__/animationDuration.ts
@@ -24,6 +24,11 @@ describe('animationDuration', () => {
     expect(result).toEqual({ animationDuration: 'a' });
   });
 
+  it('should use an interface which marks `animationDuration` as optional', () => {
+    const result = animationDuration<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = animationDuration<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/animations/__tests__/animationFillMode.ts b/src/utils/animations/__tests__/animationFillMode.ts
index aa90166..e8db5ab 100644
--- a/src/utils/animations/__tests__/animationFillMode.ts
+++ b/src/utils/animations/__tests__/animationFillMode.ts
@@ -24,6 +24,11 @@ describe('animationFillMode', () => {
     expect(result).toEqual({ animationFillMode: 'a' });
   });
 
+  it('should use an interface which marks `animationFillMode` as optional', () => {
+    const result = animationFillMode<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = animationFillMode<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/animations/__tests__/animationIterationCount.ts b/src/utils/animations/__tests__/animationIterationCount.ts
index d87b6a6..f72b109 100644
--- a/src/utils/animations/__tests__/animationIterationCount.ts
+++ b/src/utils/animations/__tests__/animationIterationCount.ts
@@ -24,6 +24,11 @@ describe('animationIterationCount', () => {
     expect(result).toEqual({ animationIterationCount: 'a' });
   });
 
+  it('should use an interface which marks `animationIterationCount` as optional', () => {
+    const result = animationIterationCount<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = animationIterationCount<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/animations/__tests__/animationName.ts b/src/utils/animations/__tests__/animationName.ts
index a08b4f6..dd7a801 100644
--- a/src/utils/animations/__tests__/animationName.ts
+++ b/src/utils/animations/__tests__/animationName.ts
@@ -24,6 +24,11 @@ describe('animationName', () => {
     expect(result).toEqual({ animationName: 'a' });
   });
 
+  it('should use an interface which marks `animationName` as optional', () => {
+    const result = animationName<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = animationName<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/animations/__tests__/animationPlayState.ts b/src/utils/animations/__tests__/animationPlayState.ts
index daecf03..3d3822e 100644
--- a/src/utils/animations/__tests__/animationPlayState.ts
+++ b/src/utils/animations/__tests__/animationPlayState.ts
@@ -24,6 +24,11 @@ describe('animationPlayState', () => {
     expect(result).toEqual({ animationPlayState: 'a' });
   });
 
+  it('should use an interface which marks `animationPlayState` as optional', () => {
+    const result = animationPlayState<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = animationPlayState<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/animations/__tests__/animationTimingFunction.ts b/src/utils/animations/__tests__/animationTimingFunction.ts
index e5bb098..7db799e 100644
--- a/src/utils/animations/__tests__/animationTimingFunction.ts
+++ b/src/utils/animations/__tests__/animationTimingFunction.ts
@@ -24,6 +24,11 @@ describe('animationTimingFunction', () => {
     expect(result).toEqual({ animationTimingFunction: 'a' });
   });
 
+  it('should use an interface which marks `animationTimingFunction` as optional', () => {
+    const result = animationTimingFunction<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = animationTimingFunction<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/backgroundAttachment.ts b/src/utils/backgrounds-and-borders/__tests__/backgroundAttachment.ts
index e85f39b..5c4b6e5 100644
--- a/src/utils/backgrounds-and-borders/__tests__/backgroundAttachment.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/backgroundAttachment.ts
@@ -24,6 +24,11 @@ describe('backgroundAttachment', () => {
     expect(result).toEqual({ backgroundAttachment: 'a' });
   });
 
+  it('should use an interface which marks `backgroundAttachment` as optional', () => {
+    const result = backgroundAttachment<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backgroundAttachment<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/backgroundClip.ts b/src/utils/backgrounds-and-borders/__tests__/backgroundClip.ts
index f99a2fc..acc9654 100644
--- a/src/utils/backgrounds-and-borders/__tests__/backgroundClip.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/backgroundClip.ts
@@ -24,6 +24,11 @@ describe('backgroundClip', () => {
     expect(result).toEqual({ backgroundClip: 'a' });
   });
 
+  it('should use an interface which marks `backgroundClip` as optional', () => {
+    const result = backgroundClip<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backgroundClip<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/backgroundColor.ts b/src/utils/backgrounds-and-borders/__tests__/backgroundColor.ts
index 9b4e4cc..da2d572 100644
--- a/src/utils/backgrounds-and-borders/__tests__/backgroundColor.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/backgroundColor.ts
@@ -24,6 +24,11 @@ describe('backgroundColor', () => {
     expect(result).toEqual({ backgroundColor: 'a' });
   });
 
+  it('should use an interface which marks `backgroundColor` as optional', () => {
+    const result = backgroundColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backgroundColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/backgroundImage.ts b/src/utils/backgrounds-and-borders/__tests__/backgroundImage.ts
index 860b271..d9b6aec 100644
--- a/src/utils/backgrounds-and-borders/__tests__/backgroundImage.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/backgroundImage.ts
@@ -24,6 +24,11 @@ describe('backgroundImage', () => {
     expect(result).toEqual({ backgroundImage: 'a' });
   });
 
+  it('should use an interface which marks `backgroundImage` as optional', () => {
+    const result = backgroundImage<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backgroundImage<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/backgroundOrigin.ts b/src/utils/backgrounds-and-borders/__tests__/backgroundOrigin.ts
index ce1119f..120f308 100644
--- a/src/utils/backgrounds-and-borders/__tests__/backgroundOrigin.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/backgroundOrigin.ts
@@ -24,6 +24,11 @@ describe('backgroundOrigin', () => {
     expect(result).toEqual({ backgroundOrigin: 'a' });
   });
 
+  it('should use an interface which marks `backgroundOrigin` as optional', () => {
+    const result = backgroundOrigin<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backgroundOrigin<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/backgroundPosition.ts b/src/utils/backgrounds-and-borders/__tests__/backgroundPosition.ts
index 5218fb0..2452897 100644
--- a/src/utils/backgrounds-and-borders/__tests__/backgroundPosition.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/backgroundPosition.ts
@@ -24,6 +24,11 @@ describe('backgroundPosition', () => {
     expect(result).toEqual({ backgroundPosition: 'a' });
   });
 
+  it('should use an interface which marks `backgroundPosition` as optional', () => {
+    const result = backgroundPosition<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backgroundPosition<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/backgroundRepeat.ts b/src/utils/backgrounds-and-borders/__tests__/backgroundRepeat.ts
index efe3106..09164e8 100644
--- a/src/utils/backgrounds-and-borders/__tests__/backgroundRepeat.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/backgroundRepeat.ts
@@ -24,6 +24,11 @@ describe('backgroundRepeat', () => {
     expect(result).toEqual({ backgroundRepeat: 'a' });
   });
 
+  it('should use an interface which marks `backgroundRepeat` as optional', () => {
+    const result = backgroundRepeat<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backgroundRepeat<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/backgroundSize.ts b/src/utils/backgrounds-and-borders/__tests__/backgroundSize.ts
index 29ac369..a60603a 100644
--- a/src/utils/backgrounds-and-borders/__tests__/backgroundSize.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/backgroundSize.ts
@@ -24,6 +24,11 @@ describe('backgroundSize', () => {
     expect(result).toEqual({ backgroundSize: 'a' });
   });
 
+  it('should use an interface which marks `backgroundSize` as optional', () => {
+    const result = backgroundSize<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backgroundSize<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/border.ts b/src/utils/backgrounds-and-borders/__tests__/border.ts
index aec9eb7..78d0a2b 100644
--- a/src/utils/backgrounds-and-borders/__tests__/border.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/border.ts
@@ -24,6 +24,11 @@ describe('border', () => {
     expect(result).toEqual({ border: 'a' });
   });
 
+  it('should use an interface which marks `border` as optional', () => {
+    const result = border<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = border<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderBottom.ts b/src/utils/backgrounds-and-borders/__tests__/borderBottom.ts
index 1781dfb..55a2fa6 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderBottom.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderBottom.ts
@@ -24,6 +24,11 @@ describe('borderBottom', () => {
     expect(result).toEqual({ borderBottom: 'a' });
   });
 
+  it('should use an interface which marks `borderBottom` as optional', () => {
+    const result = borderBottom<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBottom<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderBottomColor.ts b/src/utils/backgrounds-and-borders/__tests__/borderBottomColor.ts
index e3d7bc9..c259a24 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderBottomColor.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderBottomColor.ts
@@ -24,6 +24,11 @@ describe('borderBottomColor', () => {
     expect(result).toEqual({ borderBottomColor: 'a' });
   });
 
+  it('should use an interface which marks `borderBottomColor` as optional', () => {
+    const result = borderBottomColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBottomColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderBottomLeftRadius.ts b/src/utils/backgrounds-and-borders/__tests__/borderBottomLeftRadius.ts
index a2df060..d64f3c6 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderBottomLeftRadius.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderBottomLeftRadius.ts
@@ -24,6 +24,11 @@ describe('borderBottomLeftRadius', () => {
     expect(result).toEqual({ borderBottomLeftRadius: 'a' });
   });
 
+  it('should use an interface which marks `borderBottomLeftRadius` as optional', () => {
+    const result = borderBottomLeftRadius<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBottomLeftRadius<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderBottomRightRadius.ts b/src/utils/backgrounds-and-borders/__tests__/borderBottomRightRadius.ts
index ac73ea7..769fa06 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderBottomRightRadius.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderBottomRightRadius.ts
@@ -24,6 +24,11 @@ describe('borderBottomRightRadius', () => {
     expect(result).toEqual({ borderBottomRightRadius: 'a' });
   });
 
+  it('should use an interface which marks `borderBottomRightRadius` as optional', () => {
+    const result = borderBottomRightRadius<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBottomRightRadius<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderBottomStyle.ts b/src/utils/backgrounds-and-borders/__tests__/borderBottomStyle.ts
index e0c7e97..7006df9 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderBottomStyle.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderBottomStyle.ts
@@ -24,6 +24,11 @@ describe('borderBottomStyle', () => {
     expect(result).toEqual({ borderBottomStyle: 'a' });
   });
 
+  it('should use an interface which marks `borderBottomStyle` as optional', () => {
+    const result = borderBottomStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBottomStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderBottomWidth.ts b/src/utils/backgrounds-and-borders/__tests__/borderBottomWidth.ts
index b3cd1c1..89ad472 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderBottomWidth.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderBottomWidth.ts
@@ -24,6 +24,11 @@ describe('borderBottomWidth', () => {
     expect(result).toEqual({ borderBottomWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderBottomWidth` as optional', () => {
+    const result = borderBottomWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBottomWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderColor.ts b/src/utils/backgrounds-and-borders/__tests__/borderColor.ts
index ca8cb91..49ca719 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderColor.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderColor.ts
@@ -24,6 +24,11 @@ describe('borderColor', () => {
     expect(result).toEqual({ borderColor: 'a' });
   });
 
+  it('should use an interface which marks `borderColor` as optional', () => {
+    const result = borderColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderImage.ts b/src/utils/backgrounds-and-borders/__tests__/borderImage.ts
index f88aa59..e1150fd 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderImage.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderImage.ts
@@ -24,6 +24,11 @@ describe('borderImage', () => {
     expect(result).toEqual({ borderImage: 'a' });
   });
 
+  it('should use an interface which marks `borderImage` as optional', () => {
+    const result = borderImage<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderImage<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderImageOutset.ts b/src/utils/backgrounds-and-borders/__tests__/borderImageOutset.ts
index 4775ecc..7860ef9 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderImageOutset.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderImageOutset.ts
@@ -24,6 +24,11 @@ describe('borderImageOutset', () => {
     expect(result).toEqual({ borderImageOutset: 'a' });
   });
 
+  it('should use an interface which marks `borderImageOutset` as optional', () => {
+    const result = borderImageOutset<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderImageOutset<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderImageRepeat.ts b/src/utils/backgrounds-and-borders/__tests__/borderImageRepeat.ts
index 60f364f..2b30592 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderImageRepeat.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderImageRepeat.ts
@@ -24,6 +24,11 @@ describe('borderImageRepeat', () => {
     expect(result).toEqual({ borderImageRepeat: 'a' });
   });
 
+  it('should use an interface which marks `borderImageRepeat` as optional', () => {
+    const result = borderImageRepeat<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderImageRepeat<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderImageSlice.ts b/src/utils/backgrounds-and-borders/__tests__/borderImageSlice.ts
index cf6a1d9..a2e0c15 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderImageSlice.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderImageSlice.ts
@@ -24,6 +24,11 @@ describe('borderImageSlice', () => {
     expect(result).toEqual({ borderImageSlice: 'a' });
   });
 
+  it('should use an interface which marks `borderImageSlice` as optional', () => {
+    const result = borderImageSlice<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderImageSlice<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderImageSource.ts b/src/utils/backgrounds-and-borders/__tests__/borderImageSource.ts
index a4ebb9e..65bd499 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderImageSource.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderImageSource.ts
@@ -24,6 +24,11 @@ describe('borderImageSource', () => {
     expect(result).toEqual({ borderImageSource: 'a' });
   });
 
+  it('should use an interface which marks `borderImageSource` as optional', () => {
+    const result = borderImageSource<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderImageSource<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderImageWidth.ts b/src/utils/backgrounds-and-borders/__tests__/borderImageWidth.ts
index 56fa2ba..30d416f 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderImageWidth.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderImageWidth.ts
@@ -24,6 +24,11 @@ describe('borderImageWidth', () => {
     expect(result).toEqual({ borderImageWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderImageWidth` as optional', () => {
+    const result = borderImageWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderImageWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderLeft.ts b/src/utils/backgrounds-and-borders/__tests__/borderLeft.ts
index ac1953f..d62735e 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderLeft.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderLeft.ts
@@ -24,6 +24,11 @@ describe('borderLeft', () => {
     expect(result).toEqual({ borderLeft: 'a' });
   });
 
+  it('should use an interface which marks `borderLeft` as optional', () => {
+    const result = borderLeft<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderLeft<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderLeftColor.ts b/src/utils/backgrounds-and-borders/__tests__/borderLeftColor.ts
index fbd8643..57e173f 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderLeftColor.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderLeftColor.ts
@@ -24,6 +24,11 @@ describe('borderLeftColor', () => {
     expect(result).toEqual({ borderLeftColor: 'a' });
   });
 
+  it('should use an interface which marks `borderLeftColor` as optional', () => {
+    const result = borderLeftColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderLeftColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderLeftStyle.ts b/src/utils/backgrounds-and-borders/__tests__/borderLeftStyle.ts
index efe640f..6d0823c 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderLeftStyle.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderLeftStyle.ts
@@ -24,6 +24,11 @@ describe('borderLeftStyle', () => {
     expect(result).toEqual({ borderLeftStyle: 'a' });
   });
 
+  it('should use an interface which marks `borderLeftStyle` as optional', () => {
+    const result = borderLeftStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderLeftStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderLeftWidth.ts b/src/utils/backgrounds-and-borders/__tests__/borderLeftWidth.ts
index 7f7fe2b..6ce2253 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderLeftWidth.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderLeftWidth.ts
@@ -24,6 +24,11 @@ describe('borderLeftWidth', () => {
     expect(result).toEqual({ borderLeftWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderLeftWidth` as optional', () => {
+    const result = borderLeftWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderLeftWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderRadius.ts b/src/utils/backgrounds-and-borders/__tests__/borderRadius.ts
index e6e2722..425b64b 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderRadius.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderRadius.ts
@@ -24,6 +24,11 @@ describe('borderRadius', () => {
     expect(result).toEqual({ borderRadius: 'a' });
   });
 
+  it('should use an interface which marks `borderRadius` as optional', () => {
+    const result = borderRadius<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderRadius<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderRight.ts b/src/utils/backgrounds-and-borders/__tests__/borderRight.ts
index 8e63f5f..417d486 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderRight.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderRight.ts
@@ -24,6 +24,11 @@ describe('borderRight', () => {
     expect(result).toEqual({ borderRight: 'a' });
   });
 
+  it('should use an interface which marks `borderRight` as optional', () => {
+    const result = borderRight<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderRight<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderRightColor.ts b/src/utils/backgrounds-and-borders/__tests__/borderRightColor.ts
index f5ffe87..df4622b 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderRightColor.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderRightColor.ts
@@ -24,6 +24,11 @@ describe('borderRightColor', () => {
     expect(result).toEqual({ borderRightColor: 'a' });
   });
 
+  it('should use an interface which marks `borderRightColor` as optional', () => {
+    const result = borderRightColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderRightColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderRightStyle.ts b/src/utils/backgrounds-and-borders/__tests__/borderRightStyle.ts
index c0e4e66..b7a398c 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderRightStyle.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderRightStyle.ts
@@ -24,6 +24,11 @@ describe('borderRightStyle', () => {
     expect(result).toEqual({ borderRightStyle: 'a' });
   });
 
+  it('should use an interface which marks `borderRightStyle` as optional', () => {
+    const result = borderRightStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderRightStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderRightWidth.ts b/src/utils/backgrounds-and-borders/__tests__/borderRightWidth.ts
index dccd327..4ac8583 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderRightWidth.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderRightWidth.ts
@@ -24,6 +24,11 @@ describe('borderRightWidth', () => {
     expect(result).toEqual({ borderRightWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderRightWidth` as optional', () => {
+    const result = borderRightWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderRightWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderStyle.ts b/src/utils/backgrounds-and-borders/__tests__/borderStyle.ts
index ac30208..ac7141c 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderStyle.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderStyle.ts
@@ -24,6 +24,11 @@ describe('borderStyle', () => {
     expect(result).toEqual({ borderStyle: 'a' });
   });
 
+  it('should use an interface which marks `borderStyle` as optional', () => {
+    const result = borderStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderTop.ts b/src/utils/backgrounds-and-borders/__tests__/borderTop.ts
index f14f99f..1698033 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderTop.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderTop.ts
@@ -24,6 +24,11 @@ describe('borderTop', () => {
     expect(result).toEqual({ borderTop: 'a' });
   });
 
+  it('should use an interface which marks `borderTop` as optional', () => {
+    const result = borderTop<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderTop<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderTopColor.ts b/src/utils/backgrounds-and-borders/__tests__/borderTopColor.ts
index 836dc4f..5cd0cc9 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderTopColor.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderTopColor.ts
@@ -24,6 +24,11 @@ describe('borderTopColor', () => {
     expect(result).toEqual({ borderTopColor: 'a' });
   });
 
+  it('should use an interface which marks `borderTopColor` as optional', () => {
+    const result = borderTopColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderTopColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderTopLeftRadius.ts b/src/utils/backgrounds-and-borders/__tests__/borderTopLeftRadius.ts
index b125974..c20c279 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderTopLeftRadius.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderTopLeftRadius.ts
@@ -24,6 +24,11 @@ describe('borderTopLeftRadius', () => {
     expect(result).toEqual({ borderTopLeftRadius: 'a' });
   });
 
+  it('should use an interface which marks `borderTopLeftRadius` as optional', () => {
+    const result = borderTopLeftRadius<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderTopLeftRadius<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderTopRightRadius.ts b/src/utils/backgrounds-and-borders/__tests__/borderTopRightRadius.ts
index e587b70..3948769 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderTopRightRadius.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderTopRightRadius.ts
@@ -24,6 +24,11 @@ describe('borderTopRightRadius', () => {
     expect(result).toEqual({ borderTopRightRadius: 'a' });
   });
 
+  it('should use an interface which marks `borderTopRightRadius` as optional', () => {
+    const result = borderTopRightRadius<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderTopRightRadius<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderTopStyle.ts b/src/utils/backgrounds-and-borders/__tests__/borderTopStyle.ts
index 66b9598..d856bce 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderTopStyle.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderTopStyle.ts
@@ -24,6 +24,11 @@ describe('borderTopStyle', () => {
     expect(result).toEqual({ borderTopStyle: 'a' });
   });
 
+  it('should use an interface which marks `borderTopStyle` as optional', () => {
+    const result = borderTopStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderTopStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderTopWidth.ts b/src/utils/backgrounds-and-borders/__tests__/borderTopWidth.ts
index 512ade5..84cb85a 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderTopWidth.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderTopWidth.ts
@@ -24,6 +24,11 @@ describe('borderTopWidth', () => {
     expect(result).toEqual({ borderTopWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderTopWidth` as optional', () => {
+    const result = borderTopWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderTopWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/borderWidth.ts b/src/utils/backgrounds-and-borders/__tests__/borderWidth.ts
index adc2d4c..600710e 100644
--- a/src/utils/backgrounds-and-borders/__tests__/borderWidth.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/borderWidth.ts
@@ -24,6 +24,11 @@ describe('borderWidth', () => {
     expect(result).toEqual({ borderWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderWidth` as optional', () => {
+    const result = borderWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/__tests__/boxShadow.ts b/src/utils/backgrounds-and-borders/__tests__/boxShadow.ts
index e97953b..1b471b0 100644
--- a/src/utils/backgrounds-and-borders/__tests__/boxShadow.ts
+++ b/src/utils/backgrounds-and-borders/__tests__/boxShadow.ts
@@ -24,6 +24,11 @@ describe('boxShadow', () => {
     expect(result).toEqual({ boxShadow: 'a' });
   });
 
+  it('should use an interface which marks `boxShadow` as optional', () => {
+    const result = boxShadow<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = boxShadow<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/backgrounds-and-borders/borderBottom.ts b/src/utils/backgrounds-and-borders/borderBottom.ts
index a2ca5de..256f708 100644
--- a/src/utils/backgrounds-and-borders/borderBottom.ts
+++ b/src/utils/backgrounds-and-borders/borderBottom.ts
@@ -5,7 +5,7 @@ import { IStyleOptions } from '../../types';
 
 export interface IBorderBottomProps<T> {
   /**
-   * The **`border-bottom`** CSS property sets an element's bottom border. It's a shorthand for `border-bottom-width`, `border-bottom-style` and `border-bottom-color`.
+   * The **`border-bottom`** CSS property is a shorthand that sets the values of `border-bottom-width`, `border-bottom-style` and `border-bottom-color`. These properties set an element's bottom border.
    * 
    * @see https://developer.mozilla.org/docs/Web/CSS/border-bottom
    */
diff --git a/src/utils/backgrounds-and-borders/borderLeft.ts b/src/utils/backgrounds-and-borders/borderLeft.ts
index 34162b0..12c05f8 100644
--- a/src/utils/backgrounds-and-borders/borderLeft.ts
+++ b/src/utils/backgrounds-and-borders/borderLeft.ts
@@ -5,7 +5,7 @@ import { IStyleOptions } from '../../types';
 
 export interface IBorderLeftProps<T> {
   /**
-   * The **`border-left`** CSS property is a shorthand that sets the values of `border-left-width`, `border-left-style`, and `border-left-color`. These properties describe an element's left `border`.
+   * The **`border-left`** CSS property is a shorthand that sets the values of `border-left-width`, `border-left-style` and `border-left-color`. These properties set an element's left border.
    * 
    * @see https://developer.mozilla.org/docs/Web/CSS/border-left
    */
diff --git a/src/utils/backgrounds-and-borders/borderRight.ts b/src/utils/backgrounds-and-borders/borderRight.ts
index 02ef187..548d18b 100644
--- a/src/utils/backgrounds-and-borders/borderRight.ts
+++ b/src/utils/backgrounds-and-borders/borderRight.ts
@@ -5,7 +5,7 @@ import { IStyleOptions } from '../../types';
 
 export interface IBorderRightProps<T> {
   /**
-   * The **`border-right`** CSS property is a shorthand that sets `border-right-width`, `border-right-style`, and `border-right-color`. These properties set an element's right `border`.
+   * The **`border-right`** CSS property is a shorthand that sets the values of `border-right-width`, `border-right-style` and `border-right-color`. These properties set an element's right border.
    * 
    * @see https://developer.mozilla.org/docs/Web/CSS/border-right
    */
diff --git a/src/utils/backgrounds-and-borders/borderTop.ts b/src/utils/backgrounds-and-borders/borderTop.ts
index 92dc8e1..226f93e 100644
--- a/src/utils/backgrounds-and-borders/borderTop.ts
+++ b/src/utils/backgrounds-and-borders/borderTop.ts
@@ -5,7 +5,7 @@ import { IStyleOptions } from '../../types';
 
 export interface IBorderTopProps<T> {
   /**
-   * The **`border-top`** CSS property is a shorthand that sets the values of `border-top-width`, `border-top-style`, and `border-top-color`. These properties describe an element's top `border`.
+   * The **`border-top`** CSS property is a shorthand that sets the values of `border-top-width`, `border-top-style` and `border-top-color`. These properties set an element's top border.
    * 
    * @see https://developer.mozilla.org/docs/Web/CSS/border-top
    */
diff --git a/src/utils/basic-user-interface/__tests__/boxSizing.ts b/src/utils/basic-user-interface/__tests__/boxSizing.ts
index 5e11d3b..c79e64c 100644
--- a/src/utils/basic-user-interface/__tests__/boxSizing.ts
+++ b/src/utils/basic-user-interface/__tests__/boxSizing.ts
@@ -24,6 +24,11 @@ describe('boxSizing', () => {
     expect(result).toEqual({ boxSizing: 'a' });
   });
 
+  it('should use an interface which marks `boxSizing` as optional', () => {
+    const result = boxSizing<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = boxSizing<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/basic-user-interface/__tests__/caretColor.ts b/src/utils/basic-user-interface/__tests__/caretColor.ts
index 397e243..284372f 100644
--- a/src/utils/basic-user-interface/__tests__/caretColor.ts
+++ b/src/utils/basic-user-interface/__tests__/caretColor.ts
@@ -24,6 +24,11 @@ describe('caretColor', () => {
     expect(result).toEqual({ caretColor: 'a' });
   });
 
+  it('should use an interface which marks `caretColor` as optional', () => {
+    const result = caretColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = caretColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/basic-user-interface/__tests__/outline.ts b/src/utils/basic-user-interface/__tests__/outline.ts
index f902017..1379971 100644
--- a/src/utils/basic-user-interface/__tests__/outline.ts
+++ b/src/utils/basic-user-interface/__tests__/outline.ts
@@ -24,6 +24,11 @@ describe('outline', () => {
     expect(result).toEqual({ outline: 'a' });
   });
 
+  it('should use an interface which marks `outline` as optional', () => {
+    const result = outline<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = outline<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/basic-user-interface/__tests__/outlineColor.ts b/src/utils/basic-user-interface/__tests__/outlineColor.ts
index 1089a32..26853ea 100644
--- a/src/utils/basic-user-interface/__tests__/outlineColor.ts
+++ b/src/utils/basic-user-interface/__tests__/outlineColor.ts
@@ -24,6 +24,11 @@ describe('outlineColor', () => {
     expect(result).toEqual({ outlineColor: 'a' });
   });
 
+  it('should use an interface which marks `outlineColor` as optional', () => {
+    const result = outlineColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = outlineColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/basic-user-interface/__tests__/outlineOffset.ts b/src/utils/basic-user-interface/__tests__/outlineOffset.ts
index cec6fb4..2676c7d 100644
--- a/src/utils/basic-user-interface/__tests__/outlineOffset.ts
+++ b/src/utils/basic-user-interface/__tests__/outlineOffset.ts
@@ -24,6 +24,11 @@ describe('outlineOffset', () => {
     expect(result).toEqual({ outlineOffset: 'a' });
   });
 
+  it('should use an interface which marks `outlineOffset` as optional', () => {
+    const result = outlineOffset<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = outlineOffset<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/basic-user-interface/__tests__/outlineStyle.ts b/src/utils/basic-user-interface/__tests__/outlineStyle.ts
index 8ee5f14..4bbd31c 100644
--- a/src/utils/basic-user-interface/__tests__/outlineStyle.ts
+++ b/src/utils/basic-user-interface/__tests__/outlineStyle.ts
@@ -24,6 +24,11 @@ describe('outlineStyle', () => {
     expect(result).toEqual({ outlineStyle: 'a' });
   });
 
+  it('should use an interface which marks `outlineStyle` as optional', () => {
+    const result = outlineStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = outlineStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/basic-user-interface/__tests__/outlineWidth.ts b/src/utils/basic-user-interface/__tests__/outlineWidth.ts
index bc6fb56..83e8259 100644
--- a/src/utils/basic-user-interface/__tests__/outlineWidth.ts
+++ b/src/utils/basic-user-interface/__tests__/outlineWidth.ts
@@ -24,6 +24,11 @@ describe('outlineWidth', () => {
     expect(result).toEqual({ outlineWidth: 'a' });
   });
 
+  it('should use an interface which marks `outlineWidth` as optional', () => {
+    const result = outlineWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = outlineWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/basic-user-interface/__tests__/resize.ts b/src/utils/basic-user-interface/__tests__/resize.ts
index 687a77f..e3cfd1d 100644
--- a/src/utils/basic-user-interface/__tests__/resize.ts
+++ b/src/utils/basic-user-interface/__tests__/resize.ts
@@ -24,6 +24,11 @@ describe('resize', () => {
     expect(result).toEqual({ resize: 'a' });
   });
 
+  it('should use an interface which marks `resize` as optional', () => {
+    const result = resize<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = resize<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/basic-user-interface/__tests__/textOverflow.ts b/src/utils/basic-user-interface/__tests__/textOverflow.ts
index 83fbbbd..8ba7b1f 100644
--- a/src/utils/basic-user-interface/__tests__/textOverflow.ts
+++ b/src/utils/basic-user-interface/__tests__/textOverflow.ts
@@ -24,6 +24,11 @@ describe('textOverflow', () => {
     expect(result).toEqual({ textOverflow: 'a' });
   });
 
+  it('should use an interface which marks `textOverflow` as optional', () => {
+    const result = textOverflow<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textOverflow<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-alignment/__tests__/columnGap.ts b/src/utils/box-alignment/__tests__/columnGap.ts
index 3c7428e..ca16e7f 100644
--- a/src/utils/box-alignment/__tests__/columnGap.ts
+++ b/src/utils/box-alignment/__tests__/columnGap.ts
@@ -24,6 +24,11 @@ describe('columnGap', () => {
     expect(result).toEqual({ columnGap: 'a' });
   });
 
+  it('should use an interface which marks `columnGap` as optional', () => {
+    const result = columnGap<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columnGap<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-alignment/__tests__/gap.ts b/src/utils/box-alignment/__tests__/gap.ts
index 8eb7343..45cc71e 100644
--- a/src/utils/box-alignment/__tests__/gap.ts
+++ b/src/utils/box-alignment/__tests__/gap.ts
@@ -24,6 +24,11 @@ describe('gap', () => {
     expect(result).toEqual({ gap: 'a' });
   });
 
+  it('should use an interface which marks `gap` as optional', () => {
+    const result = gap<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gap<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-alignment/__tests__/justifyItems.ts b/src/utils/box-alignment/__tests__/justifyItems.ts
index 587f7f5..dba2e31 100644
--- a/src/utils/box-alignment/__tests__/justifyItems.ts
+++ b/src/utils/box-alignment/__tests__/justifyItems.ts
@@ -24,6 +24,11 @@ describe('justifyItems', () => {
     expect(result).toEqual({ justifyItems: 'a' });
   });
 
+  it('should use an interface which marks `justifyItems` as optional', () => {
+    const result = justifyItems<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = justifyItems<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-alignment/__tests__/justifySelf.ts b/src/utils/box-alignment/__tests__/justifySelf.ts
index 9090f53..2ee14e2 100644
--- a/src/utils/box-alignment/__tests__/justifySelf.ts
+++ b/src/utils/box-alignment/__tests__/justifySelf.ts
@@ -24,6 +24,11 @@ describe('justifySelf', () => {
     expect(result).toEqual({ justifySelf: 'a' });
   });
 
+  it('should use an interface which marks `justifySelf` as optional', () => {
+    const result = justifySelf<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = justifySelf<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-alignment/__tests__/rowGap.ts b/src/utils/box-alignment/__tests__/rowGap.ts
index ff5be1d..bbab38f 100644
--- a/src/utils/box-alignment/__tests__/rowGap.ts
+++ b/src/utils/box-alignment/__tests__/rowGap.ts
@@ -24,6 +24,11 @@ describe('rowGap', () => {
     expect(result).toEqual({ rowGap: 'a' });
   });
 
+  it('should use an interface which marks `rowGap` as optional', () => {
+    const result = rowGap<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = rowGap<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/height.ts b/src/utils/box-model/__tests__/height.ts
index 1ae1381..33f2436 100644
--- a/src/utils/box-model/__tests__/height.ts
+++ b/src/utils/box-model/__tests__/height.ts
@@ -24,6 +24,11 @@ describe('height', () => {
     expect(result).toEqual({ height: 'a' });
   });
 
+  it('should use an interface which marks `height` as optional', () => {
+    const result = height<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = height<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/margin.ts b/src/utils/box-model/__tests__/margin.ts
index 351272f..f0a7c0b 100644
--- a/src/utils/box-model/__tests__/margin.ts
+++ b/src/utils/box-model/__tests__/margin.ts
@@ -24,6 +24,11 @@ describe('margin', () => {
     expect(result).toEqual({ margin: 'a' });
   });
 
+  it('should use an interface which marks `margin` as optional', () => {
+    const result = margin<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = margin<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/marginBottom.ts b/src/utils/box-model/__tests__/marginBottom.ts
index b0e7f5c..77a5afd 100644
--- a/src/utils/box-model/__tests__/marginBottom.ts
+++ b/src/utils/box-model/__tests__/marginBottom.ts
@@ -24,6 +24,11 @@ describe('marginBottom', () => {
     expect(result).toEqual({ marginBottom: 'a' });
   });
 
+  it('should use an interface which marks `marginBottom` as optional', () => {
+    const result = marginBottom<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = marginBottom<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/marginLeft.ts b/src/utils/box-model/__tests__/marginLeft.ts
index d1d667b..fe42584 100644
--- a/src/utils/box-model/__tests__/marginLeft.ts
+++ b/src/utils/box-model/__tests__/marginLeft.ts
@@ -24,6 +24,11 @@ describe('marginLeft', () => {
     expect(result).toEqual({ marginLeft: 'a' });
   });
 
+  it('should use an interface which marks `marginLeft` as optional', () => {
+    const result = marginLeft<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = marginLeft<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/marginRight.ts b/src/utils/box-model/__tests__/marginRight.ts
index 84186f4..440b08b 100644
--- a/src/utils/box-model/__tests__/marginRight.ts
+++ b/src/utils/box-model/__tests__/marginRight.ts
@@ -24,6 +24,11 @@ describe('marginRight', () => {
     expect(result).toEqual({ marginRight: 'a' });
   });
 
+  it('should use an interface which marks `marginRight` as optional', () => {
+    const result = marginRight<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = marginRight<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/marginTop.ts b/src/utils/box-model/__tests__/marginTop.ts
index 7a037ff..1393e73 100644
--- a/src/utils/box-model/__tests__/marginTop.ts
+++ b/src/utils/box-model/__tests__/marginTop.ts
@@ -24,6 +24,11 @@ describe('marginTop', () => {
     expect(result).toEqual({ marginTop: 'a' });
   });
 
+  it('should use an interface which marks `marginTop` as optional', () => {
+    const result = marginTop<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = marginTop<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/maxHeight.ts b/src/utils/box-model/__tests__/maxHeight.ts
index 0039f17..fa6c7d1 100644
--- a/src/utils/box-model/__tests__/maxHeight.ts
+++ b/src/utils/box-model/__tests__/maxHeight.ts
@@ -24,6 +24,11 @@ describe('maxHeight', () => {
     expect(result).toEqual({ maxHeight: 'a' });
   });
 
+  it('should use an interface which marks `maxHeight` as optional', () => {
+    const result = maxHeight<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maxHeight<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/maxWidth.ts b/src/utils/box-model/__tests__/maxWidth.ts
index cbbdf51..92a6114 100644
--- a/src/utils/box-model/__tests__/maxWidth.ts
+++ b/src/utils/box-model/__tests__/maxWidth.ts
@@ -24,6 +24,11 @@ describe('maxWidth', () => {
     expect(result).toEqual({ maxWidth: 'a' });
   });
 
+  it('should use an interface which marks `maxWidth` as optional', () => {
+    const result = maxWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maxWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/minHeight.ts b/src/utils/box-model/__tests__/minHeight.ts
index e28f1ee..44d4289 100644
--- a/src/utils/box-model/__tests__/minHeight.ts
+++ b/src/utils/box-model/__tests__/minHeight.ts
@@ -24,6 +24,11 @@ describe('minHeight', () => {
     expect(result).toEqual({ minHeight: 'a' });
   });
 
+  it('should use an interface which marks `minHeight` as optional', () => {
+    const result = minHeight<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = minHeight<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/minWidth.ts b/src/utils/box-model/__tests__/minWidth.ts
index 4d4b303..b256125 100644
--- a/src/utils/box-model/__tests__/minWidth.ts
+++ b/src/utils/box-model/__tests__/minWidth.ts
@@ -24,6 +24,11 @@ describe('minWidth', () => {
     expect(result).toEqual({ minWidth: 'a' });
   });
 
+  it('should use an interface which marks `minWidth` as optional', () => {
+    const result = minWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = minWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/padding.ts b/src/utils/box-model/__tests__/padding.ts
index 1388460..da5e1b5 100644
--- a/src/utils/box-model/__tests__/padding.ts
+++ b/src/utils/box-model/__tests__/padding.ts
@@ -24,6 +24,11 @@ describe('padding', () => {
     expect(result).toEqual({ padding: 'a' });
   });
 
+  it('should use an interface which marks `padding` as optional', () => {
+    const result = padding<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = padding<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/paddingBottom.ts b/src/utils/box-model/__tests__/paddingBottom.ts
index 6887208..fa112c8 100644
--- a/src/utils/box-model/__tests__/paddingBottom.ts
+++ b/src/utils/box-model/__tests__/paddingBottom.ts
@@ -24,6 +24,11 @@ describe('paddingBottom', () => {
     expect(result).toEqual({ paddingBottom: 'a' });
   });
 
+  it('should use an interface which marks `paddingBottom` as optional', () => {
+    const result = paddingBottom<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = paddingBottom<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/paddingLeft.ts b/src/utils/box-model/__tests__/paddingLeft.ts
index 1473024..1e62349 100644
--- a/src/utils/box-model/__tests__/paddingLeft.ts
+++ b/src/utils/box-model/__tests__/paddingLeft.ts
@@ -24,6 +24,11 @@ describe('paddingLeft', () => {
     expect(result).toEqual({ paddingLeft: 'a' });
   });
 
+  it('should use an interface which marks `paddingLeft` as optional', () => {
+    const result = paddingLeft<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = paddingLeft<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/paddingRight.ts b/src/utils/box-model/__tests__/paddingRight.ts
index ebd514f..bedb4a1 100644
--- a/src/utils/box-model/__tests__/paddingRight.ts
+++ b/src/utils/box-model/__tests__/paddingRight.ts
@@ -24,6 +24,11 @@ describe('paddingRight', () => {
     expect(result).toEqual({ paddingRight: 'a' });
   });
 
+  it('should use an interface which marks `paddingRight` as optional', () => {
+    const result = paddingRight<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = paddingRight<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/paddingTop.ts b/src/utils/box-model/__tests__/paddingTop.ts
index f858a22..6234dfa 100644
--- a/src/utils/box-model/__tests__/paddingTop.ts
+++ b/src/utils/box-model/__tests__/paddingTop.ts
@@ -24,6 +24,11 @@ describe('paddingTop', () => {
     expect(result).toEqual({ paddingTop: 'a' });
   });
 
+  it('should use an interface which marks `paddingTop` as optional', () => {
+    const result = paddingTop<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = paddingTop<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/visibility.ts b/src/utils/box-model/__tests__/visibility.ts
index b8e74f1..73f4bb2 100644
--- a/src/utils/box-model/__tests__/visibility.ts
+++ b/src/utils/box-model/__tests__/visibility.ts
@@ -24,6 +24,11 @@ describe('visibility', () => {
     expect(result).toEqual({ visibility: 'a' });
   });
 
+  it('should use an interface which marks `visibility` as optional', () => {
+    const result = visibility<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = visibility<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/box-model/__tests__/width.ts b/src/utils/box-model/__tests__/width.ts
index e7b990b..e19ee2c 100644
--- a/src/utils/box-model/__tests__/width.ts
+++ b/src/utils/box-model/__tests__/width.ts
@@ -24,6 +24,11 @@ describe('width', () => {
     expect(result).toEqual({ width: 'a' });
   });
 
+  it('should use an interface which marks `width` as optional', () => {
+    const result = width<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = width<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/color/__tests__/color.ts b/src/utils/color/__tests__/color.ts
index 6451603..257ecc8 100644
--- a/src/utils/color/__tests__/color.ts
+++ b/src/utils/color/__tests__/color.ts
@@ -24,6 +24,11 @@ describe('color', () => {
     expect(result).toEqual({ color: 'a' });
   });
 
+  it('should use an interface which marks `color` as optional', () => {
+    const result = color<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = color<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/color/__tests__/colorAdjust.ts b/src/utils/color/__tests__/colorAdjust.ts
index cc5caa1..1f53dfb 100644
--- a/src/utils/color/__tests__/colorAdjust.ts
+++ b/src/utils/color/__tests__/colorAdjust.ts
@@ -24,6 +24,11 @@ describe('colorAdjust', () => {
     expect(result).toEqual({ colorAdjust: 'a' });
   });
 
+  it('should use an interface which marks `colorAdjust` as optional', () => {
+    const result = colorAdjust<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = colorAdjust<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/color/__tests__/opacity.ts b/src/utils/color/__tests__/opacity.ts
index 4cbd32a..b5ad208 100644
--- a/src/utils/color/__tests__/opacity.ts
+++ b/src/utils/color/__tests__/opacity.ts
@@ -24,6 +24,11 @@ describe('opacity', () => {
     expect(result).toEqual({ opacity: 'a' });
   });
 
+  it('should use an interface which marks `opacity` as optional', () => {
+    const result = opacity<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = opacity<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/columns/__tests__/columnCount.ts b/src/utils/columns/__tests__/columnCount.ts
index c75afcb..8f46b0a 100644
--- a/src/utils/columns/__tests__/columnCount.ts
+++ b/src/utils/columns/__tests__/columnCount.ts
@@ -24,6 +24,11 @@ describe('columnCount', () => {
     expect(result).toEqual({ columnCount: 'a' });
   });
 
+  it('should use an interface which marks `columnCount` as optional', () => {
+    const result = columnCount<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columnCount<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/columns/__tests__/columnFill.ts b/src/utils/columns/__tests__/columnFill.ts
index 1869879..ebfca56 100644
--- a/src/utils/columns/__tests__/columnFill.ts
+++ b/src/utils/columns/__tests__/columnFill.ts
@@ -24,6 +24,11 @@ describe('columnFill', () => {
     expect(result).toEqual({ columnFill: 'a' });
   });
 
+  it('should use an interface which marks `columnFill` as optional', () => {
+    const result = columnFill<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columnFill<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/columns/__tests__/columnRule.ts b/src/utils/columns/__tests__/columnRule.ts
index cff808e..cae8fe8 100644
--- a/src/utils/columns/__tests__/columnRule.ts
+++ b/src/utils/columns/__tests__/columnRule.ts
@@ -24,6 +24,11 @@ describe('columnRule', () => {
     expect(result).toEqual({ columnRule: 'a' });
   });
 
+  it('should use an interface which marks `columnRule` as optional', () => {
+    const result = columnRule<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columnRule<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/columns/__tests__/columnRuleColor.ts b/src/utils/columns/__tests__/columnRuleColor.ts
index 241a595..4757dbb 100644
--- a/src/utils/columns/__tests__/columnRuleColor.ts
+++ b/src/utils/columns/__tests__/columnRuleColor.ts
@@ -24,6 +24,11 @@ describe('columnRuleColor', () => {
     expect(result).toEqual({ columnRuleColor: 'a' });
   });
 
+  it('should use an interface which marks `columnRuleColor` as optional', () => {
+    const result = columnRuleColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columnRuleColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/columns/__tests__/columnRuleStyle.ts b/src/utils/columns/__tests__/columnRuleStyle.ts
index aca0651..1ac34a6 100644
--- a/src/utils/columns/__tests__/columnRuleStyle.ts
+++ b/src/utils/columns/__tests__/columnRuleStyle.ts
@@ -24,6 +24,11 @@ describe('columnRuleStyle', () => {
     expect(result).toEqual({ columnRuleStyle: 'a' });
   });
 
+  it('should use an interface which marks `columnRuleStyle` as optional', () => {
+    const result = columnRuleStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columnRuleStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/columns/__tests__/columnRuleWidth.ts b/src/utils/columns/__tests__/columnRuleWidth.ts
index 4c7e099..a263701 100644
--- a/src/utils/columns/__tests__/columnRuleWidth.ts
+++ b/src/utils/columns/__tests__/columnRuleWidth.ts
@@ -24,6 +24,11 @@ describe('columnRuleWidth', () => {
     expect(result).toEqual({ columnRuleWidth: 'a' });
   });
 
+  it('should use an interface which marks `columnRuleWidth` as optional', () => {
+    const result = columnRuleWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columnRuleWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/columns/__tests__/columnSpan.ts b/src/utils/columns/__tests__/columnSpan.ts
index d95dce8..08bb62a 100644
--- a/src/utils/columns/__tests__/columnSpan.ts
+++ b/src/utils/columns/__tests__/columnSpan.ts
@@ -24,6 +24,11 @@ describe('columnSpan', () => {
     expect(result).toEqual({ columnSpan: 'a' });
   });
 
+  it('should use an interface which marks `columnSpan` as optional', () => {
+    const result = columnSpan<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columnSpan<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/columns/__tests__/columnWidth.ts b/src/utils/columns/__tests__/columnWidth.ts
index 4798412..3e8131c 100644
--- a/src/utils/columns/__tests__/columnWidth.ts
+++ b/src/utils/columns/__tests__/columnWidth.ts
@@ -24,6 +24,11 @@ describe('columnWidth', () => {
     expect(result).toEqual({ columnWidth: 'a' });
   });
 
+  it('should use an interface which marks `columnWidth` as optional', () => {
+    const result = columnWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columnWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/columns/__tests__/columns.ts b/src/utils/columns/__tests__/columns.ts
index 24fede1..b0b458d 100644
--- a/src/utils/columns/__tests__/columns.ts
+++ b/src/utils/columns/__tests__/columns.ts
@@ -24,6 +24,11 @@ describe('columns', () => {
     expect(result).toEqual({ columns: 'a' });
   });
 
+  it('should use an interface which marks `columns` as optional', () => {
+    const result = columns<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = columns<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/compositing-and-blending/__tests__/backgroundBlendMode.ts b/src/utils/compositing-and-blending/__tests__/backgroundBlendMode.ts
index d788856..d0e774a 100644
--- a/src/utils/compositing-and-blending/__tests__/backgroundBlendMode.ts
+++ b/src/utils/compositing-and-blending/__tests__/backgroundBlendMode.ts
@@ -24,6 +24,11 @@ describe('backgroundBlendMode', () => {
     expect(result).toEqual({ backgroundBlendMode: 'a' });
   });
 
+  it('should use an interface which marks `backgroundBlendMode` as optional', () => {
+    const result = backgroundBlendMode<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backgroundBlendMode<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/compositing-and-blending/__tests__/isolation.ts b/src/utils/compositing-and-blending/__tests__/isolation.ts
index c60250d..3a60e56 100644
--- a/src/utils/compositing-and-blending/__tests__/isolation.ts
+++ b/src/utils/compositing-and-blending/__tests__/isolation.ts
@@ -24,6 +24,11 @@ describe('isolation', () => {
     expect(result).toEqual({ isolation: 'a' });
   });
 
+  it('should use an interface which marks `isolation` as optional', () => {
+    const result = isolation<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = isolation<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/compositing-and-blending/__tests__/mixBlendMode.ts b/src/utils/compositing-and-blending/__tests__/mixBlendMode.ts
index 95ef6a0..804cfbc 100644
--- a/src/utils/compositing-and-blending/__tests__/mixBlendMode.ts
+++ b/src/utils/compositing-and-blending/__tests__/mixBlendMode.ts
@@ -24,6 +24,11 @@ describe('mixBlendMode', () => {
     expect(result).toEqual({ mixBlendMode: 'a' });
   });
 
+  it('should use an interface which marks `mixBlendMode` as optional', () => {
+    const result = mixBlendMode<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = mixBlendMode<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/counter-styles/__tests__/counterIncrement.ts b/src/utils/counter-styles/__tests__/counterIncrement.ts
index 7a6cc18..87af2b3 100644
--- a/src/utils/counter-styles/__tests__/counterIncrement.ts
+++ b/src/utils/counter-styles/__tests__/counterIncrement.ts
@@ -24,6 +24,11 @@ describe('counterIncrement', () => {
     expect(result).toEqual({ counterIncrement: 'a' });
   });
 
+  it('should use an interface which marks `counterIncrement` as optional', () => {
+    const result = counterIncrement<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = counterIncrement<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/counter-styles/__tests__/counterReset.ts b/src/utils/counter-styles/__tests__/counterReset.ts
index 71b28fc..284f4ba 100644
--- a/src/utils/counter-styles/__tests__/counterReset.ts
+++ b/src/utils/counter-styles/__tests__/counterReset.ts
@@ -24,6 +24,11 @@ describe('counterReset', () => {
     expect(result).toEqual({ counterReset: 'a' });
   });
 
+  it('should use an interface which marks `counterReset` as optional', () => {
+    const result = counterReset<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = counterReset<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/cssom-view/__tests__/scrollBehavior.ts b/src/utils/cssom-view/__tests__/scrollBehavior.ts
index 207fb79..6942209 100644
--- a/src/utils/cssom-view/__tests__/scrollBehavior.ts
+++ b/src/utils/cssom-view/__tests__/scrollBehavior.ts
@@ -24,6 +24,11 @@ describe('scrollBehavior', () => {
     expect(result).toEqual({ scrollBehavior: 'a' });
   });
 
+  it('should use an interface which marks `scrollBehavior` as optional', () => {
+    const result = scrollBehavior<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = scrollBehavior<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/display/__tests__/display.ts b/src/utils/display/__tests__/display.ts
index 8dfa445..9d4a638 100644
--- a/src/utils/display/__tests__/display.ts
+++ b/src/utils/display/__tests__/display.ts
@@ -24,6 +24,11 @@ describe('display', () => {
     expect(result).toEqual({ display: 'a' });
   });
 
+  it('should use an interface which marks `display` as optional', () => {
+    const result = display<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = display<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/filter-effects/__tests__/filter.ts b/src/utils/filter-effects/__tests__/filter.ts
index f7619a1..cab0a3c 100644
--- a/src/utils/filter-effects/__tests__/filter.ts
+++ b/src/utils/filter-effects/__tests__/filter.ts
@@ -24,6 +24,11 @@ describe('filter', () => {
     expect(result).toEqual({ filter: 'a' });
   });
 
+  it('should use an interface which marks `filter` as optional', () => {
+    const result = filter<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = filter<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/alignContent.ts b/src/utils/flexible-box-layout/__tests__/alignContent.ts
index b8a7e7f..d1813cb 100644
--- a/src/utils/flexible-box-layout/__tests__/alignContent.ts
+++ b/src/utils/flexible-box-layout/__tests__/alignContent.ts
@@ -24,6 +24,11 @@ describe('alignContent', () => {
     expect(result).toEqual({ alignContent: 'a' });
   });
 
+  it('should use an interface which marks `alignContent` as optional', () => {
+    const result = alignContent<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = alignContent<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/alignItems.ts b/src/utils/flexible-box-layout/__tests__/alignItems.ts
index 87ecbfd..bb4ad22 100644
--- a/src/utils/flexible-box-layout/__tests__/alignItems.ts
+++ b/src/utils/flexible-box-layout/__tests__/alignItems.ts
@@ -24,6 +24,11 @@ describe('alignItems', () => {
     expect(result).toEqual({ alignItems: 'a' });
   });
 
+  it('should use an interface which marks `alignItems` as optional', () => {
+    const result = alignItems<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = alignItems<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/alignSelf.ts b/src/utils/flexible-box-layout/__tests__/alignSelf.ts
index 3c25627..ed577be 100644
--- a/src/utils/flexible-box-layout/__tests__/alignSelf.ts
+++ b/src/utils/flexible-box-layout/__tests__/alignSelf.ts
@@ -24,6 +24,11 @@ describe('alignSelf', () => {
     expect(result).toEqual({ alignSelf: 'a' });
   });
 
+  it('should use an interface which marks `alignSelf` as optional', () => {
+    const result = alignSelf<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = alignSelf<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/flex.ts b/src/utils/flexible-box-layout/__tests__/flex.ts
index 78dcaeb..8f7bb0f 100644
--- a/src/utils/flexible-box-layout/__tests__/flex.ts
+++ b/src/utils/flexible-box-layout/__tests__/flex.ts
@@ -24,6 +24,11 @@ describe('flex', () => {
     expect(result).toEqual({ flex: 'a' });
   });
 
+  it('should use an interface which marks `flex` as optional', () => {
+    const result = flex<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = flex<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/flexBasis.ts b/src/utils/flexible-box-layout/__tests__/flexBasis.ts
index dc17dd8..72c8f79 100644
--- a/src/utils/flexible-box-layout/__tests__/flexBasis.ts
+++ b/src/utils/flexible-box-layout/__tests__/flexBasis.ts
@@ -24,6 +24,11 @@ describe('flexBasis', () => {
     expect(result).toEqual({ flexBasis: 'a' });
   });
 
+  it('should use an interface which marks `flexBasis` as optional', () => {
+    const result = flexBasis<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = flexBasis<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/flexDirection.ts b/src/utils/flexible-box-layout/__tests__/flexDirection.ts
index ce28159..219b366 100644
--- a/src/utils/flexible-box-layout/__tests__/flexDirection.ts
+++ b/src/utils/flexible-box-layout/__tests__/flexDirection.ts
@@ -24,6 +24,11 @@ describe('flexDirection', () => {
     expect(result).toEqual({ flexDirection: 'a' });
   });
 
+  it('should use an interface which marks `flexDirection` as optional', () => {
+    const result = flexDirection<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = flexDirection<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/flexFlow.ts b/src/utils/flexible-box-layout/__tests__/flexFlow.ts
index 32b37fa..61be1b0 100644
--- a/src/utils/flexible-box-layout/__tests__/flexFlow.ts
+++ b/src/utils/flexible-box-layout/__tests__/flexFlow.ts
@@ -24,6 +24,11 @@ describe('flexFlow', () => {
     expect(result).toEqual({ flexFlow: 'a' });
   });
 
+  it('should use an interface which marks `flexFlow` as optional', () => {
+    const result = flexFlow<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = flexFlow<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/flexGrow.ts b/src/utils/flexible-box-layout/__tests__/flexGrow.ts
index 8fd91e4..c8225af 100644
--- a/src/utils/flexible-box-layout/__tests__/flexGrow.ts
+++ b/src/utils/flexible-box-layout/__tests__/flexGrow.ts
@@ -24,6 +24,11 @@ describe('flexGrow', () => {
     expect(result).toEqual({ flexGrow: 'a' });
   });
 
+  it('should use an interface which marks `flexGrow` as optional', () => {
+    const result = flexGrow<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = flexGrow<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/flexShrink.ts b/src/utils/flexible-box-layout/__tests__/flexShrink.ts
index d1b2668..cf02515 100644
--- a/src/utils/flexible-box-layout/__tests__/flexShrink.ts
+++ b/src/utils/flexible-box-layout/__tests__/flexShrink.ts
@@ -24,6 +24,11 @@ describe('flexShrink', () => {
     expect(result).toEqual({ flexShrink: 'a' });
   });
 
+  it('should use an interface which marks `flexShrink` as optional', () => {
+    const result = flexShrink<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = flexShrink<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/flexWrap.ts b/src/utils/flexible-box-layout/__tests__/flexWrap.ts
index eee7b3c..30f4cec 100644
--- a/src/utils/flexible-box-layout/__tests__/flexWrap.ts
+++ b/src/utils/flexible-box-layout/__tests__/flexWrap.ts
@@ -24,6 +24,11 @@ describe('flexWrap', () => {
     expect(result).toEqual({ flexWrap: 'a' });
   });
 
+  it('should use an interface which marks `flexWrap` as optional', () => {
+    const result = flexWrap<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = flexWrap<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/justifyContent.ts b/src/utils/flexible-box-layout/__tests__/justifyContent.ts
index 3b6d0dc..26f762a 100644
--- a/src/utils/flexible-box-layout/__tests__/justifyContent.ts
+++ b/src/utils/flexible-box-layout/__tests__/justifyContent.ts
@@ -24,6 +24,11 @@ describe('justifyContent', () => {
     expect(result).toEqual({ justifyContent: 'a' });
   });
 
+  it('should use an interface which marks `justifyContent` as optional', () => {
+    const result = justifyContent<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = justifyContent<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/order.ts b/src/utils/flexible-box-layout/__tests__/order.ts
index d8ecb79..8507d10 100644
--- a/src/utils/flexible-box-layout/__tests__/order.ts
+++ b/src/utils/flexible-box-layout/__tests__/order.ts
@@ -24,6 +24,11 @@ describe('order', () => {
     expect(result).toEqual({ order: 'a' });
   });
 
+  it('should use an interface which marks `order` as optional', () => {
+    const result = order<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = order<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/flexible-box-layout/__tests__/placeContent.ts b/src/utils/flexible-box-layout/__tests__/placeContent.ts
index 5b1fb07..7901fd2 100644
--- a/src/utils/flexible-box-layout/__tests__/placeContent.ts
+++ b/src/utils/flexible-box-layout/__tests__/placeContent.ts
@@ -24,6 +24,11 @@ describe('placeContent', () => {
     expect(result).toEqual({ placeContent: 'a' });
   });
 
+  it('should use an interface which marks `placeContent` as optional', () => {
+    const result = placeContent<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = placeContent<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/font.ts b/src/utils/fonts/__tests__/font.ts
index b6098ad..1c18f50 100644
--- a/src/utils/fonts/__tests__/font.ts
+++ b/src/utils/fonts/__tests__/font.ts
@@ -24,6 +24,11 @@ describe('font', () => {
     expect(result).toEqual({ font: 'a' });
   });
 
+  it('should use an interface which marks `font` as optional', () => {
+    const result = font<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = font<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontFamily.ts b/src/utils/fonts/__tests__/fontFamily.ts
index f046b2a..b21f0a3 100644
--- a/src/utils/fonts/__tests__/fontFamily.ts
+++ b/src/utils/fonts/__tests__/fontFamily.ts
@@ -24,6 +24,11 @@ describe('fontFamily', () => {
     expect(result).toEqual({ fontFamily: 'a' });
   });
 
+  it('should use an interface which marks `fontFamily` as optional', () => {
+    const result = fontFamily<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontFamily<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontFeatureSettings.ts b/src/utils/fonts/__tests__/fontFeatureSettings.ts
index 443ef71..3ec06ae 100644
--- a/src/utils/fonts/__tests__/fontFeatureSettings.ts
+++ b/src/utils/fonts/__tests__/fontFeatureSettings.ts
@@ -24,6 +24,11 @@ describe('fontFeatureSettings', () => {
     expect(result).toEqual({ fontFeatureSettings: 'a' });
   });
 
+  it('should use an interface which marks `fontFeatureSettings` as optional', () => {
+    const result = fontFeatureSettings<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontFeatureSettings<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontKerning.ts b/src/utils/fonts/__tests__/fontKerning.ts
index d455448..4f631a7 100644
--- a/src/utils/fonts/__tests__/fontKerning.ts
+++ b/src/utils/fonts/__tests__/fontKerning.ts
@@ -24,6 +24,11 @@ describe('fontKerning', () => {
     expect(result).toEqual({ fontKerning: 'a' });
   });
 
+  it('should use an interface which marks `fontKerning` as optional', () => {
+    const result = fontKerning<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontKerning<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontLanguageOverride.ts b/src/utils/fonts/__tests__/fontLanguageOverride.ts
index 1eb38f6..8f77bab 100644
--- a/src/utils/fonts/__tests__/fontLanguageOverride.ts
+++ b/src/utils/fonts/__tests__/fontLanguageOverride.ts
@@ -24,6 +24,11 @@ describe('fontLanguageOverride', () => {
     expect(result).toEqual({ fontLanguageOverride: 'a' });
   });
 
+  it('should use an interface which marks `fontLanguageOverride` as optional', () => {
+    const result = fontLanguageOverride<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontLanguageOverride<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontOpticalSizing.ts b/src/utils/fonts/__tests__/fontOpticalSizing.ts
index b7fc519..5d466d1 100644
--- a/src/utils/fonts/__tests__/fontOpticalSizing.ts
+++ b/src/utils/fonts/__tests__/fontOpticalSizing.ts
@@ -24,6 +24,11 @@ describe('fontOpticalSizing', () => {
     expect(result).toEqual({ fontOpticalSizing: 'a' });
   });
 
+  it('should use an interface which marks `fontOpticalSizing` as optional', () => {
+    const result = fontOpticalSizing<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontOpticalSizing<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontSize.ts b/src/utils/fonts/__tests__/fontSize.ts
index 46597db..86f42e1 100644
--- a/src/utils/fonts/__tests__/fontSize.ts
+++ b/src/utils/fonts/__tests__/fontSize.ts
@@ -24,6 +24,11 @@ describe('fontSize', () => {
     expect(result).toEqual({ fontSize: 'a' });
   });
 
+  it('should use an interface which marks `fontSize` as optional', () => {
+    const result = fontSize<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontSize<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontSizeAdjust.ts b/src/utils/fonts/__tests__/fontSizeAdjust.ts
index 31d0d5d..db1235f 100644
--- a/src/utils/fonts/__tests__/fontSizeAdjust.ts
+++ b/src/utils/fonts/__tests__/fontSizeAdjust.ts
@@ -24,6 +24,11 @@ describe('fontSizeAdjust', () => {
     expect(result).toEqual({ fontSizeAdjust: 'a' });
   });
 
+  it('should use an interface which marks `fontSizeAdjust` as optional', () => {
+    const result = fontSizeAdjust<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontSizeAdjust<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontStretch.ts b/src/utils/fonts/__tests__/fontStretch.ts
index 98522a9..d21ee3c 100644
--- a/src/utils/fonts/__tests__/fontStretch.ts
+++ b/src/utils/fonts/__tests__/fontStretch.ts
@@ -24,6 +24,11 @@ describe('fontStretch', () => {
     expect(result).toEqual({ fontStretch: 'a' });
   });
 
+  it('should use an interface which marks `fontStretch` as optional', () => {
+    const result = fontStretch<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontStretch<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontStyle.ts b/src/utils/fonts/__tests__/fontStyle.ts
index 57cab79..e978b01 100644
--- a/src/utils/fonts/__tests__/fontStyle.ts
+++ b/src/utils/fonts/__tests__/fontStyle.ts
@@ -24,6 +24,11 @@ describe('fontStyle', () => {
     expect(result).toEqual({ fontStyle: 'a' });
   });
 
+  it('should use an interface which marks `fontStyle` as optional', () => {
+    const result = fontStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontSynthesis.ts b/src/utils/fonts/__tests__/fontSynthesis.ts
index dad99b9..26d82d0 100644
--- a/src/utils/fonts/__tests__/fontSynthesis.ts
+++ b/src/utils/fonts/__tests__/fontSynthesis.ts
@@ -24,6 +24,11 @@ describe('fontSynthesis', () => {
     expect(result).toEqual({ fontSynthesis: 'a' });
   });
 
+  it('should use an interface which marks `fontSynthesis` as optional', () => {
+    const result = fontSynthesis<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontSynthesis<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontVariant.ts b/src/utils/fonts/__tests__/fontVariant.ts
index 3d3e3de..10cb58c 100644
--- a/src/utils/fonts/__tests__/fontVariant.ts
+++ b/src/utils/fonts/__tests__/fontVariant.ts
@@ -24,6 +24,11 @@ describe('fontVariant', () => {
     expect(result).toEqual({ fontVariant: 'a' });
   });
 
+  it('should use an interface which marks `fontVariant` as optional', () => {
+    const result = fontVariant<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontVariant<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontVariantAlternates.ts b/src/utils/fonts/__tests__/fontVariantAlternates.ts
index a7077eb..f2eb0c8 100644
--- a/src/utils/fonts/__tests__/fontVariantAlternates.ts
+++ b/src/utils/fonts/__tests__/fontVariantAlternates.ts
@@ -24,6 +24,11 @@ describe('fontVariantAlternates', () => {
     expect(result).toEqual({ fontVariantAlternates: 'a' });
   });
 
+  it('should use an interface which marks `fontVariantAlternates` as optional', () => {
+    const result = fontVariantAlternates<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontVariantAlternates<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontVariantCaps.ts b/src/utils/fonts/__tests__/fontVariantCaps.ts
index 4861076..5d52d33 100644
--- a/src/utils/fonts/__tests__/fontVariantCaps.ts
+++ b/src/utils/fonts/__tests__/fontVariantCaps.ts
@@ -24,6 +24,11 @@ describe('fontVariantCaps', () => {
     expect(result).toEqual({ fontVariantCaps: 'a' });
   });
 
+  it('should use an interface which marks `fontVariantCaps` as optional', () => {
+    const result = fontVariantCaps<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontVariantCaps<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontVariantEastAsian.ts b/src/utils/fonts/__tests__/fontVariantEastAsian.ts
index 2371be3..a0f3d72 100644
--- a/src/utils/fonts/__tests__/fontVariantEastAsian.ts
+++ b/src/utils/fonts/__tests__/fontVariantEastAsian.ts
@@ -24,6 +24,11 @@ describe('fontVariantEastAsian', () => {
     expect(result).toEqual({ fontVariantEastAsian: 'a' });
   });
 
+  it('should use an interface which marks `fontVariantEastAsian` as optional', () => {
+    const result = fontVariantEastAsian<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontVariantEastAsian<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontVariantLigatures.ts b/src/utils/fonts/__tests__/fontVariantLigatures.ts
index 38dabc2..1ebd1a8 100644
--- a/src/utils/fonts/__tests__/fontVariantLigatures.ts
+++ b/src/utils/fonts/__tests__/fontVariantLigatures.ts
@@ -24,6 +24,11 @@ describe('fontVariantLigatures', () => {
     expect(result).toEqual({ fontVariantLigatures: 'a' });
   });
 
+  it('should use an interface which marks `fontVariantLigatures` as optional', () => {
+    const result = fontVariantLigatures<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontVariantLigatures<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontVariantNumeric.ts b/src/utils/fonts/__tests__/fontVariantNumeric.ts
index 1b0f9ef..0074abe 100644
--- a/src/utils/fonts/__tests__/fontVariantNumeric.ts
+++ b/src/utils/fonts/__tests__/fontVariantNumeric.ts
@@ -24,6 +24,11 @@ describe('fontVariantNumeric', () => {
     expect(result).toEqual({ fontVariantNumeric: 'a' });
   });
 
+  it('should use an interface which marks `fontVariantNumeric` as optional', () => {
+    const result = fontVariantNumeric<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontVariantNumeric<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontVariantPosition.ts b/src/utils/fonts/__tests__/fontVariantPosition.ts
index 9a92649..13ed06c 100644
--- a/src/utils/fonts/__tests__/fontVariantPosition.ts
+++ b/src/utils/fonts/__tests__/fontVariantPosition.ts
@@ -24,6 +24,11 @@ describe('fontVariantPosition', () => {
     expect(result).toEqual({ fontVariantPosition: 'a' });
   });
 
+  it('should use an interface which marks `fontVariantPosition` as optional', () => {
+    const result = fontVariantPosition<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontVariantPosition<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/fontWeight.ts b/src/utils/fonts/__tests__/fontWeight.ts
index 7b491d9..fabdad7 100644
--- a/src/utils/fonts/__tests__/fontWeight.ts
+++ b/src/utils/fonts/__tests__/fontWeight.ts
@@ -24,6 +24,11 @@ describe('fontWeight', () => {
     expect(result).toEqual({ fontWeight: 'a' });
   });
 
+  it('should use an interface which marks `fontWeight` as optional', () => {
+    const result = fontWeight<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = fontWeight<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fonts/__tests__/lineHeight.ts b/src/utils/fonts/__tests__/lineHeight.ts
index 67844ae..5d8b79d 100644
--- a/src/utils/fonts/__tests__/lineHeight.ts
+++ b/src/utils/fonts/__tests__/lineHeight.ts
@@ -24,6 +24,11 @@ describe('lineHeight', () => {
     expect(result).toEqual({ lineHeight: 'a' });
   });
 
+  it('should use an interface which marks `lineHeight` as optional', () => {
+    const result = lineHeight<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = lineHeight<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fragmentation/__tests__/boxDecorationBreak.ts b/src/utils/fragmentation/__tests__/boxDecorationBreak.ts
index a8adaf4..20b35d7 100644
--- a/src/utils/fragmentation/__tests__/boxDecorationBreak.ts
+++ b/src/utils/fragmentation/__tests__/boxDecorationBreak.ts
@@ -24,6 +24,11 @@ describe('boxDecorationBreak', () => {
     expect(result).toEqual({ boxDecorationBreak: 'a' });
   });
 
+  it('should use an interface which marks `boxDecorationBreak` as optional', () => {
+    const result = boxDecorationBreak<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = boxDecorationBreak<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fragmentation/__tests__/breakAfter.ts b/src/utils/fragmentation/__tests__/breakAfter.ts
index 89238bf..691fef6 100644
--- a/src/utils/fragmentation/__tests__/breakAfter.ts
+++ b/src/utils/fragmentation/__tests__/breakAfter.ts
@@ -24,6 +24,11 @@ describe('breakAfter', () => {
     expect(result).toEqual({ breakAfter: 'a' });
   });
 
+  it('should use an interface which marks `breakAfter` as optional', () => {
+    const result = breakAfter<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = breakAfter<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fragmentation/__tests__/breakBefore.ts b/src/utils/fragmentation/__tests__/breakBefore.ts
index bcad886..b0dd798 100644
--- a/src/utils/fragmentation/__tests__/breakBefore.ts
+++ b/src/utils/fragmentation/__tests__/breakBefore.ts
@@ -24,6 +24,11 @@ describe('breakBefore', () => {
     expect(result).toEqual({ breakBefore: 'a' });
   });
 
+  it('should use an interface which marks `breakBefore` as optional', () => {
+    const result = breakBefore<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = breakBefore<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fragmentation/__tests__/breakInside.ts b/src/utils/fragmentation/__tests__/breakInside.ts
index e6ebbbf..2b5e117 100644
--- a/src/utils/fragmentation/__tests__/breakInside.ts
+++ b/src/utils/fragmentation/__tests__/breakInside.ts
@@ -24,6 +24,11 @@ describe('breakInside', () => {
     expect(result).toEqual({ breakInside: 'a' });
   });
 
+  it('should use an interface which marks `breakInside` as optional', () => {
+    const result = breakInside<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = breakInside<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fragmentation/__tests__/orphans.ts b/src/utils/fragmentation/__tests__/orphans.ts
index b679559..58bc51b 100644
--- a/src/utils/fragmentation/__tests__/orphans.ts
+++ b/src/utils/fragmentation/__tests__/orphans.ts
@@ -24,6 +24,11 @@ describe('orphans', () => {
     expect(result).toEqual({ orphans: 'a' });
   });
 
+  it('should use an interface which marks `orphans` as optional', () => {
+    const result = orphans<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = orphans<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/fragmentation/__tests__/widows.ts b/src/utils/fragmentation/__tests__/widows.ts
index 3d17f60..30a2b54 100644
--- a/src/utils/fragmentation/__tests__/widows.ts
+++ b/src/utils/fragmentation/__tests__/widows.ts
@@ -24,6 +24,11 @@ describe('widows', () => {
     expect(result).toEqual({ widows: 'a' });
   });
 
+  it('should use an interface which marks `widows` as optional', () => {
+    const result = widows<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = widows<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/generated-content/__tests__/content.ts b/src/utils/generated-content/__tests__/content.ts
index 63ef530..e779a33 100644
--- a/src/utils/generated-content/__tests__/content.ts
+++ b/src/utils/generated-content/__tests__/content.ts
@@ -24,6 +24,11 @@ describe('content', () => {
     expect(result).toEqual({ content: 'a' });
   });
 
+  it('should use an interface which marks `content` as optional', () => {
+    const result = content<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = content<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/generated-content/__tests__/quotes.ts b/src/utils/generated-content/__tests__/quotes.ts
index 9153ae1..3c5bd12 100644
--- a/src/utils/generated-content/__tests__/quotes.ts
+++ b/src/utils/generated-content/__tests__/quotes.ts
@@ -24,6 +24,11 @@ describe('quotes', () => {
     expect(result).toEqual({ quotes: 'a' });
   });
 
+  it('should use an interface which marks `quotes` as optional', () => {
+    const result = quotes<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = quotes<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/grid.ts b/src/utils/grid-layout/__tests__/grid.ts
index ab48449..38411d5 100644
--- a/src/utils/grid-layout/__tests__/grid.ts
+++ b/src/utils/grid-layout/__tests__/grid.ts
@@ -24,6 +24,11 @@ describe('grid', () => {
     expect(result).toEqual({ grid: 'a' });
   });
 
+  it('should use an interface which marks `grid` as optional', () => {
+    const result = grid<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = grid<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridArea.ts b/src/utils/grid-layout/__tests__/gridArea.ts
index 2b112d2..62c02ee 100644
--- a/src/utils/grid-layout/__tests__/gridArea.ts
+++ b/src/utils/grid-layout/__tests__/gridArea.ts
@@ -24,6 +24,11 @@ describe('gridArea', () => {
     expect(result).toEqual({ gridArea: 'a' });
   });
 
+  it('should use an interface which marks `gridArea` as optional', () => {
+    const result = gridArea<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridArea<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridAutoColumns.ts b/src/utils/grid-layout/__tests__/gridAutoColumns.ts
index 7c28eb5..5708edc 100644
--- a/src/utils/grid-layout/__tests__/gridAutoColumns.ts
+++ b/src/utils/grid-layout/__tests__/gridAutoColumns.ts
@@ -24,6 +24,11 @@ describe('gridAutoColumns', () => {
     expect(result).toEqual({ gridAutoColumns: 'a' });
   });
 
+  it('should use an interface which marks `gridAutoColumns` as optional', () => {
+    const result = gridAutoColumns<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridAutoColumns<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridAutoFlow.ts b/src/utils/grid-layout/__tests__/gridAutoFlow.ts
index 57d70a7..739054b 100644
--- a/src/utils/grid-layout/__tests__/gridAutoFlow.ts
+++ b/src/utils/grid-layout/__tests__/gridAutoFlow.ts
@@ -24,6 +24,11 @@ describe('gridAutoFlow', () => {
     expect(result).toEqual({ gridAutoFlow: 'a' });
   });
 
+  it('should use an interface which marks `gridAutoFlow` as optional', () => {
+    const result = gridAutoFlow<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridAutoFlow<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridAutoRows.ts b/src/utils/grid-layout/__tests__/gridAutoRows.ts
index 36070a8..5b685f9 100644
--- a/src/utils/grid-layout/__tests__/gridAutoRows.ts
+++ b/src/utils/grid-layout/__tests__/gridAutoRows.ts
@@ -24,6 +24,11 @@ describe('gridAutoRows', () => {
     expect(result).toEqual({ gridAutoRows: 'a' });
   });
 
+  it('should use an interface which marks `gridAutoRows` as optional', () => {
+    const result = gridAutoRows<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridAutoRows<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridColumn.ts b/src/utils/grid-layout/__tests__/gridColumn.ts
index aed2155..88f82f7 100644
--- a/src/utils/grid-layout/__tests__/gridColumn.ts
+++ b/src/utils/grid-layout/__tests__/gridColumn.ts
@@ -24,6 +24,11 @@ describe('gridColumn', () => {
     expect(result).toEqual({ gridColumn: 'a' });
   });
 
+  it('should use an interface which marks `gridColumn` as optional', () => {
+    const result = gridColumn<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridColumn<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridColumnEnd.ts b/src/utils/grid-layout/__tests__/gridColumnEnd.ts
index d4b727d..92bfaad 100644
--- a/src/utils/grid-layout/__tests__/gridColumnEnd.ts
+++ b/src/utils/grid-layout/__tests__/gridColumnEnd.ts
@@ -24,6 +24,11 @@ describe('gridColumnEnd', () => {
     expect(result).toEqual({ gridColumnEnd: 'a' });
   });
 
+  it('should use an interface which marks `gridColumnEnd` as optional', () => {
+    const result = gridColumnEnd<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridColumnEnd<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridColumnStart.ts b/src/utils/grid-layout/__tests__/gridColumnStart.ts
index 92d9023..59f07ca 100644
--- a/src/utils/grid-layout/__tests__/gridColumnStart.ts
+++ b/src/utils/grid-layout/__tests__/gridColumnStart.ts
@@ -24,6 +24,11 @@ describe('gridColumnStart', () => {
     expect(result).toEqual({ gridColumnStart: 'a' });
   });
 
+  it('should use an interface which marks `gridColumnStart` as optional', () => {
+    const result = gridColumnStart<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridColumnStart<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridRow.ts b/src/utils/grid-layout/__tests__/gridRow.ts
index 6bd1bbd..2f9b6a5 100644
--- a/src/utils/grid-layout/__tests__/gridRow.ts
+++ b/src/utils/grid-layout/__tests__/gridRow.ts
@@ -24,6 +24,11 @@ describe('gridRow', () => {
     expect(result).toEqual({ gridRow: 'a' });
   });
 
+  it('should use an interface which marks `gridRow` as optional', () => {
+    const result = gridRow<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridRow<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridRowEnd.ts b/src/utils/grid-layout/__tests__/gridRowEnd.ts
index c42182d..c2dec90 100644
--- a/src/utils/grid-layout/__tests__/gridRowEnd.ts
+++ b/src/utils/grid-layout/__tests__/gridRowEnd.ts
@@ -24,6 +24,11 @@ describe('gridRowEnd', () => {
     expect(result).toEqual({ gridRowEnd: 'a' });
   });
 
+  it('should use an interface which marks `gridRowEnd` as optional', () => {
+    const result = gridRowEnd<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridRowEnd<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridRowStart.ts b/src/utils/grid-layout/__tests__/gridRowStart.ts
index cdd38ed..a042668 100644
--- a/src/utils/grid-layout/__tests__/gridRowStart.ts
+++ b/src/utils/grid-layout/__tests__/gridRowStart.ts
@@ -24,6 +24,11 @@ describe('gridRowStart', () => {
     expect(result).toEqual({ gridRowStart: 'a' });
   });
 
+  it('should use an interface which marks `gridRowStart` as optional', () => {
+    const result = gridRowStart<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridRowStart<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridTemplate.ts b/src/utils/grid-layout/__tests__/gridTemplate.ts
index 0ff4f95..88055a9 100644
--- a/src/utils/grid-layout/__tests__/gridTemplate.ts
+++ b/src/utils/grid-layout/__tests__/gridTemplate.ts
@@ -24,6 +24,11 @@ describe('gridTemplate', () => {
     expect(result).toEqual({ gridTemplate: 'a' });
   });
 
+  it('should use an interface which marks `gridTemplate` as optional', () => {
+    const result = gridTemplate<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridTemplate<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridTemplateAreas.ts b/src/utils/grid-layout/__tests__/gridTemplateAreas.ts
index 3419f7a..a7e0509 100644
--- a/src/utils/grid-layout/__tests__/gridTemplateAreas.ts
+++ b/src/utils/grid-layout/__tests__/gridTemplateAreas.ts
@@ -24,6 +24,11 @@ describe('gridTemplateAreas', () => {
     expect(result).toEqual({ gridTemplateAreas: 'a' });
   });
 
+  it('should use an interface which marks `gridTemplateAreas` as optional', () => {
+    const result = gridTemplateAreas<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridTemplateAreas<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridTemplateColumns.ts b/src/utils/grid-layout/__tests__/gridTemplateColumns.ts
index db2bbaa..9463486 100644
--- a/src/utils/grid-layout/__tests__/gridTemplateColumns.ts
+++ b/src/utils/grid-layout/__tests__/gridTemplateColumns.ts
@@ -24,6 +24,11 @@ describe('gridTemplateColumns', () => {
     expect(result).toEqual({ gridTemplateColumns: 'a' });
   });
 
+  it('should use an interface which marks `gridTemplateColumns` as optional', () => {
+    const result = gridTemplateColumns<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridTemplateColumns<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/grid-layout/__tests__/gridTemplateRows.ts b/src/utils/grid-layout/__tests__/gridTemplateRows.ts
index 94603f3..1d0e51b 100644
--- a/src/utils/grid-layout/__tests__/gridTemplateRows.ts
+++ b/src/utils/grid-layout/__tests__/gridTemplateRows.ts
@@ -24,6 +24,11 @@ describe('gridTemplateRows', () => {
     expect(result).toEqual({ gridTemplateRows: 'a' });
   });
 
+  it('should use an interface which marks `gridTemplateRows` as optional', () => {
+    const result = gridTemplateRows<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = gridTemplateRows<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/images/__tests__/imageOrientation.ts b/src/utils/images/__tests__/imageOrientation.ts
index 2ba1703..a8e8433 100644
--- a/src/utils/images/__tests__/imageOrientation.ts
+++ b/src/utils/images/__tests__/imageOrientation.ts
@@ -24,6 +24,11 @@ describe('imageOrientation', () => {
     expect(result).toEqual({ imageOrientation: 'a' });
   });
 
+  it('should use an interface which marks `imageOrientation` as optional', () => {
+    const result = imageOrientation<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = imageOrientation<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/images/__tests__/imageRendering.ts b/src/utils/images/__tests__/imageRendering.ts
index 1650152..ca3cd29 100644
--- a/src/utils/images/__tests__/imageRendering.ts
+++ b/src/utils/images/__tests__/imageRendering.ts
@@ -24,6 +24,11 @@ describe('imageRendering', () => {
     expect(result).toEqual({ imageRendering: 'a' });
   });
 
+  it('should use an interface which marks `imageRendering` as optional', () => {
+    const result = imageRendering<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = imageRendering<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/images/__tests__/objectFit.ts b/src/utils/images/__tests__/objectFit.ts
index a74e7a0..0567fad 100644
--- a/src/utils/images/__tests__/objectFit.ts
+++ b/src/utils/images/__tests__/objectFit.ts
@@ -24,6 +24,11 @@ describe('objectFit', () => {
     expect(result).toEqual({ objectFit: 'a' });
   });
 
+  it('should use an interface which marks `objectFit` as optional', () => {
+    const result = objectFit<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = objectFit<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/images/__tests__/objectPosition.ts b/src/utils/images/__tests__/objectPosition.ts
index 6bdd962..f42e145 100644
--- a/src/utils/images/__tests__/objectPosition.ts
+++ b/src/utils/images/__tests__/objectPosition.ts
@@ -24,6 +24,11 @@ describe('objectPosition', () => {
     expect(result).toEqual({ objectPosition: 'a' });
   });
 
+  it('should use an interface which marks `objectPosition` as optional', () => {
+    const result = objectPosition<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = objectPosition<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/lists-and-counters/__tests__/listStyle.ts b/src/utils/lists-and-counters/__tests__/listStyle.ts
index 8778f24..c78d392 100644
--- a/src/utils/lists-and-counters/__tests__/listStyle.ts
+++ b/src/utils/lists-and-counters/__tests__/listStyle.ts
@@ -24,6 +24,11 @@ describe('listStyle', () => {
     expect(result).toEqual({ listStyle: 'a' });
   });
 
+  it('should use an interface which marks `listStyle` as optional', () => {
+    const result = listStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = listStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/lists-and-counters/__tests__/listStyleImage.ts b/src/utils/lists-and-counters/__tests__/listStyleImage.ts
index 66b8f5e..2f3853e 100644
--- a/src/utils/lists-and-counters/__tests__/listStyleImage.ts
+++ b/src/utils/lists-and-counters/__tests__/listStyleImage.ts
@@ -24,6 +24,11 @@ describe('listStyleImage', () => {
     expect(result).toEqual({ listStyleImage: 'a' });
   });
 
+  it('should use an interface which marks `listStyleImage` as optional', () => {
+    const result = listStyleImage<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = listStyleImage<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/lists-and-counters/__tests__/listStylePosition.ts b/src/utils/lists-and-counters/__tests__/listStylePosition.ts
index 7762f7a..c4404ce 100644
--- a/src/utils/lists-and-counters/__tests__/listStylePosition.ts
+++ b/src/utils/lists-and-counters/__tests__/listStylePosition.ts
@@ -24,6 +24,11 @@ describe('listStylePosition', () => {
     expect(result).toEqual({ listStylePosition: 'a' });
   });
 
+  it('should use an interface which marks `listStylePosition` as optional', () => {
+    const result = listStylePosition<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = listStylePosition<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/lists-and-counters/__tests__/listStyleType.ts b/src/utils/lists-and-counters/__tests__/listStyleType.ts
index 7b804af..3fad220 100644
--- a/src/utils/lists-and-counters/__tests__/listStyleType.ts
+++ b/src/utils/lists-and-counters/__tests__/listStyleType.ts
@@ -24,6 +24,11 @@ describe('listStyleType', () => {
     expect(result).toEqual({ listStyleType: 'a' });
   });
 
+  it('should use an interface which marks `listStyleType` as optional', () => {
+    const result = listStyleType<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = listStyleType<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/blockSize.ts b/src/utils/logical-properties/__tests__/blockSize.ts
index 12f92a3..6062e53 100644
--- a/src/utils/logical-properties/__tests__/blockSize.ts
+++ b/src/utils/logical-properties/__tests__/blockSize.ts
@@ -24,6 +24,11 @@ describe('blockSize', () => {
     expect(result).toEqual({ blockSize: 'a' });
   });
 
+  it('should use an interface which marks `blockSize` as optional', () => {
+    const result = blockSize<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = blockSize<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderBlockEnd.ts b/src/utils/logical-properties/__tests__/borderBlockEnd.ts
index 007ed48..50fc602 100644
--- a/src/utils/logical-properties/__tests__/borderBlockEnd.ts
+++ b/src/utils/logical-properties/__tests__/borderBlockEnd.ts
@@ -24,6 +24,11 @@ describe('borderBlockEnd', () => {
     expect(result).toEqual({ borderBlockEnd: 'a' });
   });
 
+  it('should use an interface which marks `borderBlockEnd` as optional', () => {
+    const result = borderBlockEnd<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBlockEnd<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderBlockEndColor.ts b/src/utils/logical-properties/__tests__/borderBlockEndColor.ts
index f46e94d..7bd0502 100644
--- a/src/utils/logical-properties/__tests__/borderBlockEndColor.ts
+++ b/src/utils/logical-properties/__tests__/borderBlockEndColor.ts
@@ -24,6 +24,11 @@ describe('borderBlockEndColor', () => {
     expect(result).toEqual({ borderBlockEndColor: 'a' });
   });
 
+  it('should use an interface which marks `borderBlockEndColor` as optional', () => {
+    const result = borderBlockEndColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBlockEndColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderBlockEndStyle.ts b/src/utils/logical-properties/__tests__/borderBlockEndStyle.ts
index 52007b7..8aa2af6 100644
--- a/src/utils/logical-properties/__tests__/borderBlockEndStyle.ts
+++ b/src/utils/logical-properties/__tests__/borderBlockEndStyle.ts
@@ -24,6 +24,11 @@ describe('borderBlockEndStyle', () => {
     expect(result).toEqual({ borderBlockEndStyle: 'a' });
   });
 
+  it('should use an interface which marks `borderBlockEndStyle` as optional', () => {
+    const result = borderBlockEndStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBlockEndStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderBlockEndWidth.ts b/src/utils/logical-properties/__tests__/borderBlockEndWidth.ts
index 0f979fe..8ed6310 100644
--- a/src/utils/logical-properties/__tests__/borderBlockEndWidth.ts
+++ b/src/utils/logical-properties/__tests__/borderBlockEndWidth.ts
@@ -24,6 +24,11 @@ describe('borderBlockEndWidth', () => {
     expect(result).toEqual({ borderBlockEndWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderBlockEndWidth` as optional', () => {
+    const result = borderBlockEndWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBlockEndWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderBlockStart.ts b/src/utils/logical-properties/__tests__/borderBlockStart.ts
index 154fe1b..4afc3be 100644
--- a/src/utils/logical-properties/__tests__/borderBlockStart.ts
+++ b/src/utils/logical-properties/__tests__/borderBlockStart.ts
@@ -24,6 +24,11 @@ describe('borderBlockStart', () => {
     expect(result).toEqual({ borderBlockStart: 'a' });
   });
 
+  it('should use an interface which marks `borderBlockStart` as optional', () => {
+    const result = borderBlockStart<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBlockStart<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderBlockStartColor.ts b/src/utils/logical-properties/__tests__/borderBlockStartColor.ts
index 90e995f..15b70cd 100644
--- a/src/utils/logical-properties/__tests__/borderBlockStartColor.ts
+++ b/src/utils/logical-properties/__tests__/borderBlockStartColor.ts
@@ -24,6 +24,11 @@ describe('borderBlockStartColor', () => {
     expect(result).toEqual({ borderBlockStartColor: 'a' });
   });
 
+  it('should use an interface which marks `borderBlockStartColor` as optional', () => {
+    const result = borderBlockStartColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBlockStartColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderBlockStartStyle.ts b/src/utils/logical-properties/__tests__/borderBlockStartStyle.ts
index d32c6b0..bdc2815 100644
--- a/src/utils/logical-properties/__tests__/borderBlockStartStyle.ts
+++ b/src/utils/logical-properties/__tests__/borderBlockStartStyle.ts
@@ -24,6 +24,11 @@ describe('borderBlockStartStyle', () => {
     expect(result).toEqual({ borderBlockStartStyle: 'a' });
   });
 
+  it('should use an interface which marks `borderBlockStartStyle` as optional', () => {
+    const result = borderBlockStartStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBlockStartStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderBlockStartWidth.ts b/src/utils/logical-properties/__tests__/borderBlockStartWidth.ts
index 7d61b85..2338575 100644
--- a/src/utils/logical-properties/__tests__/borderBlockStartWidth.ts
+++ b/src/utils/logical-properties/__tests__/borderBlockStartWidth.ts
@@ -24,6 +24,11 @@ describe('borderBlockStartWidth', () => {
     expect(result).toEqual({ borderBlockStartWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderBlockStartWidth` as optional', () => {
+    const result = borderBlockStartWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderBlockStartWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderInlineEnd.ts b/src/utils/logical-properties/__tests__/borderInlineEnd.ts
index f8cdced..db2064b 100644
--- a/src/utils/logical-properties/__tests__/borderInlineEnd.ts
+++ b/src/utils/logical-properties/__tests__/borderInlineEnd.ts
@@ -24,6 +24,11 @@ describe('borderInlineEnd', () => {
     expect(result).toEqual({ borderInlineEnd: 'a' });
   });
 
+  it('should use an interface which marks `borderInlineEnd` as optional', () => {
+    const result = borderInlineEnd<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderInlineEnd<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderInlineEndColor.ts b/src/utils/logical-properties/__tests__/borderInlineEndColor.ts
index fbd534d..4aa2526 100644
--- a/src/utils/logical-properties/__tests__/borderInlineEndColor.ts
+++ b/src/utils/logical-properties/__tests__/borderInlineEndColor.ts
@@ -24,6 +24,11 @@ describe('borderInlineEndColor', () => {
     expect(result).toEqual({ borderInlineEndColor: 'a' });
   });
 
+  it('should use an interface which marks `borderInlineEndColor` as optional', () => {
+    const result = borderInlineEndColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderInlineEndColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderInlineEndStyle.ts b/src/utils/logical-properties/__tests__/borderInlineEndStyle.ts
index 840a50e..211f2a8 100644
--- a/src/utils/logical-properties/__tests__/borderInlineEndStyle.ts
+++ b/src/utils/logical-properties/__tests__/borderInlineEndStyle.ts
@@ -24,6 +24,11 @@ describe('borderInlineEndStyle', () => {
     expect(result).toEqual({ borderInlineEndStyle: 'a' });
   });
 
+  it('should use an interface which marks `borderInlineEndStyle` as optional', () => {
+    const result = borderInlineEndStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderInlineEndStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderInlineEndWidth.ts b/src/utils/logical-properties/__tests__/borderInlineEndWidth.ts
index c5197ce..75fdcb2 100644
--- a/src/utils/logical-properties/__tests__/borderInlineEndWidth.ts
+++ b/src/utils/logical-properties/__tests__/borderInlineEndWidth.ts
@@ -24,6 +24,11 @@ describe('borderInlineEndWidth', () => {
     expect(result).toEqual({ borderInlineEndWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderInlineEndWidth` as optional', () => {
+    const result = borderInlineEndWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderInlineEndWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderInlineStart.ts b/src/utils/logical-properties/__tests__/borderInlineStart.ts
index 0103e69..c1755b2 100644
--- a/src/utils/logical-properties/__tests__/borderInlineStart.ts
+++ b/src/utils/logical-properties/__tests__/borderInlineStart.ts
@@ -24,6 +24,11 @@ describe('borderInlineStart', () => {
     expect(result).toEqual({ borderInlineStart: 'a' });
   });
 
+  it('should use an interface which marks `borderInlineStart` as optional', () => {
+    const result = borderInlineStart<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderInlineStart<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderInlineStartColor.ts b/src/utils/logical-properties/__tests__/borderInlineStartColor.ts
index abdd7e7..5173806 100644
--- a/src/utils/logical-properties/__tests__/borderInlineStartColor.ts
+++ b/src/utils/logical-properties/__tests__/borderInlineStartColor.ts
@@ -24,6 +24,11 @@ describe('borderInlineStartColor', () => {
     expect(result).toEqual({ borderInlineStartColor: 'a' });
   });
 
+  it('should use an interface which marks `borderInlineStartColor` as optional', () => {
+    const result = borderInlineStartColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderInlineStartColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderInlineStartStyle.ts b/src/utils/logical-properties/__tests__/borderInlineStartStyle.ts
index 21b5494..ae013f7 100644
--- a/src/utils/logical-properties/__tests__/borderInlineStartStyle.ts
+++ b/src/utils/logical-properties/__tests__/borderInlineStartStyle.ts
@@ -24,6 +24,11 @@ describe('borderInlineStartStyle', () => {
     expect(result).toEqual({ borderInlineStartStyle: 'a' });
   });
 
+  it('should use an interface which marks `borderInlineStartStyle` as optional', () => {
+    const result = borderInlineStartStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderInlineStartStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/borderInlineStartWidth.ts b/src/utils/logical-properties/__tests__/borderInlineStartWidth.ts
index ca5f394..076bf67 100644
--- a/src/utils/logical-properties/__tests__/borderInlineStartWidth.ts
+++ b/src/utils/logical-properties/__tests__/borderInlineStartWidth.ts
@@ -24,6 +24,11 @@ describe('borderInlineStartWidth', () => {
     expect(result).toEqual({ borderInlineStartWidth: 'a' });
   });
 
+  it('should use an interface which marks `borderInlineStartWidth` as optional', () => {
+    const result = borderInlineStartWidth<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderInlineStartWidth<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/inlineSize.ts b/src/utils/logical-properties/__tests__/inlineSize.ts
index 1168860..63868a2 100644
--- a/src/utils/logical-properties/__tests__/inlineSize.ts
+++ b/src/utils/logical-properties/__tests__/inlineSize.ts
@@ -24,6 +24,11 @@ describe('inlineSize', () => {
     expect(result).toEqual({ inlineSize: 'a' });
   });
 
+  it('should use an interface which marks `inlineSize` as optional', () => {
+    const result = inlineSize<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = inlineSize<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/marginBlockEnd.ts b/src/utils/logical-properties/__tests__/marginBlockEnd.ts
index 26fd141..d34aed2 100644
--- a/src/utils/logical-properties/__tests__/marginBlockEnd.ts
+++ b/src/utils/logical-properties/__tests__/marginBlockEnd.ts
@@ -24,6 +24,11 @@ describe('marginBlockEnd', () => {
     expect(result).toEqual({ marginBlockEnd: 'a' });
   });
 
+  it('should use an interface which marks `marginBlockEnd` as optional', () => {
+    const result = marginBlockEnd<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = marginBlockEnd<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/marginBlockStart.ts b/src/utils/logical-properties/__tests__/marginBlockStart.ts
index 85da8b3..c4a1521 100644
--- a/src/utils/logical-properties/__tests__/marginBlockStart.ts
+++ b/src/utils/logical-properties/__tests__/marginBlockStart.ts
@@ -24,6 +24,11 @@ describe('marginBlockStart', () => {
     expect(result).toEqual({ marginBlockStart: 'a' });
   });
 
+  it('should use an interface which marks `marginBlockStart` as optional', () => {
+    const result = marginBlockStart<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = marginBlockStart<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/marginInlineEnd.ts b/src/utils/logical-properties/__tests__/marginInlineEnd.ts
index 8a634a0..08af6b0 100644
--- a/src/utils/logical-properties/__tests__/marginInlineEnd.ts
+++ b/src/utils/logical-properties/__tests__/marginInlineEnd.ts
@@ -24,6 +24,11 @@ describe('marginInlineEnd', () => {
     expect(result).toEqual({ marginInlineEnd: 'a' });
   });
 
+  it('should use an interface which marks `marginInlineEnd` as optional', () => {
+    const result = marginInlineEnd<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = marginInlineEnd<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/marginInlineStart.ts b/src/utils/logical-properties/__tests__/marginInlineStart.ts
index 4cebc4e..14a7796 100644
--- a/src/utils/logical-properties/__tests__/marginInlineStart.ts
+++ b/src/utils/logical-properties/__tests__/marginInlineStart.ts
@@ -24,6 +24,11 @@ describe('marginInlineStart', () => {
     expect(result).toEqual({ marginInlineStart: 'a' });
   });
 
+  it('should use an interface which marks `marginInlineStart` as optional', () => {
+    const result = marginInlineStart<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = marginInlineStart<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/minBlockSize.ts b/src/utils/logical-properties/__tests__/minBlockSize.ts
index 8efec68..6ed2969 100644
--- a/src/utils/logical-properties/__tests__/minBlockSize.ts
+++ b/src/utils/logical-properties/__tests__/minBlockSize.ts
@@ -24,6 +24,11 @@ describe('minBlockSize', () => {
     expect(result).toEqual({ minBlockSize: 'a' });
   });
 
+  it('should use an interface which marks `minBlockSize` as optional', () => {
+    const result = minBlockSize<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = minBlockSize<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/minInlineSize.ts b/src/utils/logical-properties/__tests__/minInlineSize.ts
index bd51478..9ed4eeb 100644
--- a/src/utils/logical-properties/__tests__/minInlineSize.ts
+++ b/src/utils/logical-properties/__tests__/minInlineSize.ts
@@ -24,6 +24,11 @@ describe('minInlineSize', () => {
     expect(result).toEqual({ minInlineSize: 'a' });
   });
 
+  it('should use an interface which marks `minInlineSize` as optional', () => {
+    const result = minInlineSize<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = minInlineSize<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/paddingBlockEnd.ts b/src/utils/logical-properties/__tests__/paddingBlockEnd.ts
index c968543..a4c4ebf 100644
--- a/src/utils/logical-properties/__tests__/paddingBlockEnd.ts
+++ b/src/utils/logical-properties/__tests__/paddingBlockEnd.ts
@@ -24,6 +24,11 @@ describe('paddingBlockEnd', () => {
     expect(result).toEqual({ paddingBlockEnd: 'a' });
   });
 
+  it('should use an interface which marks `paddingBlockEnd` as optional', () => {
+    const result = paddingBlockEnd<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = paddingBlockEnd<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/paddingBlockStart.ts b/src/utils/logical-properties/__tests__/paddingBlockStart.ts
index 3b9f0e8..6c3a7fe 100644
--- a/src/utils/logical-properties/__tests__/paddingBlockStart.ts
+++ b/src/utils/logical-properties/__tests__/paddingBlockStart.ts
@@ -24,6 +24,11 @@ describe('paddingBlockStart', () => {
     expect(result).toEqual({ paddingBlockStart: 'a' });
   });
 
+  it('should use an interface which marks `paddingBlockStart` as optional', () => {
+    const result = paddingBlockStart<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = paddingBlockStart<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/paddingInlineEnd.ts b/src/utils/logical-properties/__tests__/paddingInlineEnd.ts
index 01f0246..aa9bbff 100644
--- a/src/utils/logical-properties/__tests__/paddingInlineEnd.ts
+++ b/src/utils/logical-properties/__tests__/paddingInlineEnd.ts
@@ -24,6 +24,11 @@ describe('paddingInlineEnd', () => {
     expect(result).toEqual({ paddingInlineEnd: 'a' });
   });
 
+  it('should use an interface which marks `paddingInlineEnd` as optional', () => {
+    const result = paddingInlineEnd<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = paddingInlineEnd<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/logical-properties/__tests__/paddingInlineStart.ts b/src/utils/logical-properties/__tests__/paddingInlineStart.ts
index 10bd7fa..28d64c8 100644
--- a/src/utils/logical-properties/__tests__/paddingInlineStart.ts
+++ b/src/utils/logical-properties/__tests__/paddingInlineStart.ts
@@ -24,6 +24,11 @@ describe('paddingInlineStart', () => {
     expect(result).toEqual({ paddingInlineStart: 'a' });
   });
 
+  it('should use an interface which marks `paddingInlineStart` as optional', () => {
+    const result = paddingInlineStart<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = paddingInlineStart<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/clip.ts b/src/utils/masking/__tests__/clip.ts
index 198b96b..3898aa4 100644
--- a/src/utils/masking/__tests__/clip.ts
+++ b/src/utils/masking/__tests__/clip.ts
@@ -24,6 +24,11 @@ describe('clip', () => {
     expect(result).toEqual({ clip: 'a' });
   });
 
+  it('should use an interface which marks `clip` as optional', () => {
+    const result = clip<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = clip<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/clipPath.ts b/src/utils/masking/__tests__/clipPath.ts
index 833bd59..e66668f 100644
--- a/src/utils/masking/__tests__/clipPath.ts
+++ b/src/utils/masking/__tests__/clipPath.ts
@@ -24,6 +24,11 @@ describe('clipPath', () => {
     expect(result).toEqual({ clipPath: 'a' });
   });
 
+  it('should use an interface which marks `clipPath` as optional', () => {
+    const result = clipPath<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = clipPath<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/mask.ts b/src/utils/masking/__tests__/mask.ts
index a4df4b4..166b600 100644
--- a/src/utils/masking/__tests__/mask.ts
+++ b/src/utils/masking/__tests__/mask.ts
@@ -24,6 +24,11 @@ describe('mask', () => {
     expect(result).toEqual({ mask: 'a' });
   });
 
+  it('should use an interface which marks `mask` as optional', () => {
+    const result = mask<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = mask<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/maskClip.ts b/src/utils/masking/__tests__/maskClip.ts
index 4fa5212..2e953a7 100644
--- a/src/utils/masking/__tests__/maskClip.ts
+++ b/src/utils/masking/__tests__/maskClip.ts
@@ -24,6 +24,11 @@ describe('maskClip', () => {
     expect(result).toEqual({ maskClip: 'a' });
   });
 
+  it('should use an interface which marks `maskClip` as optional', () => {
+    const result = maskClip<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maskClip<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/maskComposite.ts b/src/utils/masking/__tests__/maskComposite.ts
index 6b63447..2babf08 100644
--- a/src/utils/masking/__tests__/maskComposite.ts
+++ b/src/utils/masking/__tests__/maskComposite.ts
@@ -24,6 +24,11 @@ describe('maskComposite', () => {
     expect(result).toEqual({ maskComposite: 'a' });
   });
 
+  it('should use an interface which marks `maskComposite` as optional', () => {
+    const result = maskComposite<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maskComposite<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/maskImage.ts b/src/utils/masking/__tests__/maskImage.ts
index 4018ed6..afd8893 100644
--- a/src/utils/masking/__tests__/maskImage.ts
+++ b/src/utils/masking/__tests__/maskImage.ts
@@ -24,6 +24,11 @@ describe('maskImage', () => {
     expect(result).toEqual({ maskImage: 'a' });
   });
 
+  it('should use an interface which marks `maskImage` as optional', () => {
+    const result = maskImage<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maskImage<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/maskMode.ts b/src/utils/masking/__tests__/maskMode.ts
index 6a0b927..2092093 100644
--- a/src/utils/masking/__tests__/maskMode.ts
+++ b/src/utils/masking/__tests__/maskMode.ts
@@ -24,6 +24,11 @@ describe('maskMode', () => {
     expect(result).toEqual({ maskMode: 'a' });
   });
 
+  it('should use an interface which marks `maskMode` as optional', () => {
+    const result = maskMode<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maskMode<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/maskOrigin.ts b/src/utils/masking/__tests__/maskOrigin.ts
index a14c1cf..d0bb449 100644
--- a/src/utils/masking/__tests__/maskOrigin.ts
+++ b/src/utils/masking/__tests__/maskOrigin.ts
@@ -24,6 +24,11 @@ describe('maskOrigin', () => {
     expect(result).toEqual({ maskOrigin: 'a' });
   });
 
+  it('should use an interface which marks `maskOrigin` as optional', () => {
+    const result = maskOrigin<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maskOrigin<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/maskPosition.ts b/src/utils/masking/__tests__/maskPosition.ts
index c9ed8ef..b0cab6e 100644
--- a/src/utils/masking/__tests__/maskPosition.ts
+++ b/src/utils/masking/__tests__/maskPosition.ts
@@ -24,6 +24,11 @@ describe('maskPosition', () => {
     expect(result).toEqual({ maskPosition: 'a' });
   });
 
+  it('should use an interface which marks `maskPosition` as optional', () => {
+    const result = maskPosition<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maskPosition<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/maskRepeat.ts b/src/utils/masking/__tests__/maskRepeat.ts
index 149381d..766e533 100644
--- a/src/utils/masking/__tests__/maskRepeat.ts
+++ b/src/utils/masking/__tests__/maskRepeat.ts
@@ -24,6 +24,11 @@ describe('maskRepeat', () => {
     expect(result).toEqual({ maskRepeat: 'a' });
   });
 
+  it('should use an interface which marks `maskRepeat` as optional', () => {
+    const result = maskRepeat<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maskRepeat<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/maskSize.ts b/src/utils/masking/__tests__/maskSize.ts
index 0554112..753d61a 100644
--- a/src/utils/masking/__tests__/maskSize.ts
+++ b/src/utils/masking/__tests__/maskSize.ts
@@ -24,6 +24,11 @@ describe('maskSize', () => {
     expect(result).toEqual({ maskSize: 'a' });
   });
 
+  it('should use an interface which marks `maskSize` as optional', () => {
+    const result = maskSize<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maskSize<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/masking/__tests__/maskType.ts b/src/utils/masking/__tests__/maskType.ts
index f39bec0..03349c1 100644
--- a/src/utils/masking/__tests__/maskType.ts
+++ b/src/utils/masking/__tests__/maskType.ts
@@ -24,6 +24,11 @@ describe('maskType', () => {
     expect(result).toEqual({ maskType: 'a' });
   });
 
+  it('should use an interface which marks `maskType` as optional', () => {
+    const result = maskType<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = maskType<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/miscellaneous/__tests__/all.ts b/src/utils/miscellaneous/__tests__/all.ts
index 8bf0749..8be19b9 100644
--- a/src/utils/miscellaneous/__tests__/all.ts
+++ b/src/utils/miscellaneous/__tests__/all.ts
@@ -24,6 +24,11 @@ describe('all', () => {
     expect(result).toEqual({ all: 'a' });
   });
 
+  it('should use an interface which marks `all` as optional', () => {
+    const result = all<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = all<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/miscellaneous/__tests__/textRendering.ts b/src/utils/miscellaneous/__tests__/textRendering.ts
index d2f7ca2..6b41e0a 100644
--- a/src/utils/miscellaneous/__tests__/textRendering.ts
+++ b/src/utils/miscellaneous/__tests__/textRendering.ts
@@ -24,6 +24,11 @@ describe('textRendering', () => {
     expect(result).toEqual({ textRendering: 'a' });
   });
 
+  it('should use an interface which marks `textRendering` as optional', () => {
+    const result = textRendering<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textRendering<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/overflow/__tests__/overflow.ts b/src/utils/overflow/__tests__/overflow.ts
index be49110..b2d2df2 100644
--- a/src/utils/overflow/__tests__/overflow.ts
+++ b/src/utils/overflow/__tests__/overflow.ts
@@ -24,6 +24,11 @@ describe('overflow', () => {
     expect(result).toEqual({ overflow: 'a' });
   });
 
+  it('should use an interface which marks `overflow` as optional', () => {
+    const result = overflow<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = overflow<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/overflow/__tests__/overflowX.ts b/src/utils/overflow/__tests__/overflowX.ts
index e8f3845..a3186ea 100644
--- a/src/utils/overflow/__tests__/overflowX.ts
+++ b/src/utils/overflow/__tests__/overflowX.ts
@@ -24,6 +24,11 @@ describe('overflowX', () => {
     expect(result).toEqual({ overflowX: 'a' });
   });
 
+  it('should use an interface which marks `overflowX` as optional', () => {
+    const result = overflowX<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = overflowX<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/overflow/__tests__/overflowY.ts b/src/utils/overflow/__tests__/overflowY.ts
index 67d7df4..6441d98 100644
--- a/src/utils/overflow/__tests__/overflowY.ts
+++ b/src/utils/overflow/__tests__/overflowY.ts
@@ -24,6 +24,11 @@ describe('overflowY', () => {
     expect(result).toEqual({ overflowY: 'a' });
   });
 
+  it('should use an interface which marks `overflowY` as optional', () => {
+    const result = overflowY<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = overflowY<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/pages/__tests__/pageBreakAfter.ts b/src/utils/pages/__tests__/pageBreakAfter.ts
index 4c349df..f08e551 100644
--- a/src/utils/pages/__tests__/pageBreakAfter.ts
+++ b/src/utils/pages/__tests__/pageBreakAfter.ts
@@ -24,6 +24,11 @@ describe('pageBreakAfter', () => {
     expect(result).toEqual({ pageBreakAfter: 'a' });
   });
 
+  it('should use an interface which marks `pageBreakAfter` as optional', () => {
+    const result = pageBreakAfter<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = pageBreakAfter<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/pages/__tests__/pageBreakBefore.ts b/src/utils/pages/__tests__/pageBreakBefore.ts
index 66549db..bdaa600 100644
--- a/src/utils/pages/__tests__/pageBreakBefore.ts
+++ b/src/utils/pages/__tests__/pageBreakBefore.ts
@@ -24,6 +24,11 @@ describe('pageBreakBefore', () => {
     expect(result).toEqual({ pageBreakBefore: 'a' });
   });
 
+  it('should use an interface which marks `pageBreakBefore` as optional', () => {
+    const result = pageBreakBefore<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = pageBreakBefore<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/pages/__tests__/pageBreakInside.ts b/src/utils/pages/__tests__/pageBreakInside.ts
index 4b551c5..2bcf375 100644
--- a/src/utils/pages/__tests__/pageBreakInside.ts
+++ b/src/utils/pages/__tests__/pageBreakInside.ts
@@ -24,6 +24,11 @@ describe('pageBreakInside', () => {
     expect(result).toEqual({ pageBreakInside: 'a' });
   });
 
+  it('should use an interface which marks `pageBreakInside` as optional', () => {
+    const result = pageBreakInside<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = pageBreakInside<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/pointer-events/__tests__/pointerEvents.ts b/src/utils/pointer-events/__tests__/pointerEvents.ts
index 5dae206..bbb683a 100644
--- a/src/utils/pointer-events/__tests__/pointerEvents.ts
+++ b/src/utils/pointer-events/__tests__/pointerEvents.ts
@@ -24,6 +24,11 @@ describe('pointerEvents', () => {
     expect(result).toEqual({ pointerEvents: 'a' });
   });
 
+  it('should use an interface which marks `pointerEvents` as optional', () => {
+    const result = pointerEvents<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = pointerEvents<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/pointer-events/__tests__/touchAction.ts b/src/utils/pointer-events/__tests__/touchAction.ts
index aa49d1d..118a690 100644
--- a/src/utils/pointer-events/__tests__/touchAction.ts
+++ b/src/utils/pointer-events/__tests__/touchAction.ts
@@ -24,6 +24,11 @@ describe('touchAction', () => {
     expect(result).toEqual({ touchAction: 'a' });
   });
 
+  it('should use an interface which marks `touchAction` as optional', () => {
+    const result = touchAction<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = touchAction<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/positioning/__tests__/bottom.ts b/src/utils/positioning/__tests__/bottom.ts
index bb4b2ba..ee5da72 100644
--- a/src/utils/positioning/__tests__/bottom.ts
+++ b/src/utils/positioning/__tests__/bottom.ts
@@ -24,6 +24,11 @@ describe('bottom', () => {
     expect(result).toEqual({ bottom: 'a' });
   });
 
+  it('should use an interface which marks `bottom` as optional', () => {
+    const result = bottom<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = bottom<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/positioning/__tests__/clear.ts b/src/utils/positioning/__tests__/clear.ts
index a852924..d235318 100644
--- a/src/utils/positioning/__tests__/clear.ts
+++ b/src/utils/positioning/__tests__/clear.ts
@@ -24,6 +24,11 @@ describe('clear', () => {
     expect(result).toEqual({ clear: 'a' });
   });
 
+  it('should use an interface which marks `clear` as optional', () => {
+    const result = clear<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = clear<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/positioning/__tests__/float.ts b/src/utils/positioning/__tests__/float.ts
index 1d86dbc..1bfce6b 100644
--- a/src/utils/positioning/__tests__/float.ts
+++ b/src/utils/positioning/__tests__/float.ts
@@ -24,6 +24,11 @@ describe('float', () => {
     expect(result).toEqual({ float: 'a' });
   });
 
+  it('should use an interface which marks `float` as optional', () => {
+    const result = float<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = float<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/positioning/__tests__/left.ts b/src/utils/positioning/__tests__/left.ts
index c07c480..100cfa7 100644
--- a/src/utils/positioning/__tests__/left.ts
+++ b/src/utils/positioning/__tests__/left.ts
@@ -24,6 +24,11 @@ describe('left', () => {
     expect(result).toEqual({ left: 'a' });
   });
 
+  it('should use an interface which marks `left` as optional', () => {
+    const result = left<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = left<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/positioning/__tests__/position.ts b/src/utils/positioning/__tests__/position.ts
index 21e9a65..b392885 100644
--- a/src/utils/positioning/__tests__/position.ts
+++ b/src/utils/positioning/__tests__/position.ts
@@ -24,6 +24,11 @@ describe('position', () => {
     expect(result).toEqual({ position: 'a' });
   });
 
+  it('should use an interface which marks `position` as optional', () => {
+    const result = position<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = position<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/positioning/__tests__/right.ts b/src/utils/positioning/__tests__/right.ts
index ee6a4cf..3487d74 100644
--- a/src/utils/positioning/__tests__/right.ts
+++ b/src/utils/positioning/__tests__/right.ts
@@ -24,6 +24,11 @@ describe('right', () => {
     expect(result).toEqual({ right: 'a' });
   });
 
+  it('should use an interface which marks `right` as optional', () => {
+    const result = right<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = right<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/positioning/__tests__/top.ts b/src/utils/positioning/__tests__/top.ts
index a28bd1d..73259c8 100644
--- a/src/utils/positioning/__tests__/top.ts
+++ b/src/utils/positioning/__tests__/top.ts
@@ -24,6 +24,11 @@ describe('top', () => {
     expect(result).toEqual({ top: 'a' });
   });
 
+  it('should use an interface which marks `top` as optional', () => {
+    const result = top<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = top<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/positioning/__tests__/zIndex.ts b/src/utils/positioning/__tests__/zIndex.ts
index f78e4a7..a97ee47 100644
--- a/src/utils/positioning/__tests__/zIndex.ts
+++ b/src/utils/positioning/__tests__/zIndex.ts
@@ -24,6 +24,11 @@ describe('zIndex', () => {
     expect(result).toEqual({ zIndex: 'a' });
   });
 
+  it('should use an interface which marks `zIndex` as optional', () => {
+    const result = zIndex<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = zIndex<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/scroll-snap/__tests__/scrollSnapType.ts b/src/utils/scroll-snap/__tests__/scrollSnapType.ts
index 456e8bf..a7f29c5 100644
--- a/src/utils/scroll-snap/__tests__/scrollSnapType.ts
+++ b/src/utils/scroll-snap/__tests__/scrollSnapType.ts
@@ -24,6 +24,11 @@ describe('scrollSnapType', () => {
     expect(result).toEqual({ scrollSnapType: 'a' });
   });
 
+  it('should use an interface which marks `scrollSnapType` as optional', () => {
+    const result = scrollSnapType<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = scrollSnapType<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/shapes/__tests__/shapeImageThreshold.ts b/src/utils/shapes/__tests__/shapeImageThreshold.ts
index ce926a1..4f64c0b 100644
--- a/src/utils/shapes/__tests__/shapeImageThreshold.ts
+++ b/src/utils/shapes/__tests__/shapeImageThreshold.ts
@@ -24,6 +24,11 @@ describe('shapeImageThreshold', () => {
     expect(result).toEqual({ shapeImageThreshold: 'a' });
   });
 
+  it('should use an interface which marks `shapeImageThreshold` as optional', () => {
+    const result = shapeImageThreshold<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = shapeImageThreshold<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/shapes/__tests__/shapeMargin.ts b/src/utils/shapes/__tests__/shapeMargin.ts
index ae80302..25a836e 100644
--- a/src/utils/shapes/__tests__/shapeMargin.ts
+++ b/src/utils/shapes/__tests__/shapeMargin.ts
@@ -24,6 +24,11 @@ describe('shapeMargin', () => {
     expect(result).toEqual({ shapeMargin: 'a' });
   });
 
+  it('should use an interface which marks `shapeMargin` as optional', () => {
+    const result = shapeMargin<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = shapeMargin<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/shapes/__tests__/shapeOutside.ts b/src/utils/shapes/__tests__/shapeOutside.ts
index ca7dc78..79cf38a 100644
--- a/src/utils/shapes/__tests__/shapeOutside.ts
+++ b/src/utils/shapes/__tests__/shapeOutside.ts
@@ -24,6 +24,11 @@ describe('shapeOutside', () => {
     expect(result).toEqual({ shapeOutside: 'a' });
   });
 
+  it('should use an interface which marks `shapeOutside` as optional', () => {
+    const result = shapeOutside<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = shapeOutside<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/table/__tests__/borderCollapse.ts b/src/utils/table/__tests__/borderCollapse.ts
index 1ca2556..e47bede 100644
--- a/src/utils/table/__tests__/borderCollapse.ts
+++ b/src/utils/table/__tests__/borderCollapse.ts
@@ -24,6 +24,11 @@ describe('borderCollapse', () => {
     expect(result).toEqual({ borderCollapse: 'a' });
   });
 
+  it('should use an interface which marks `borderCollapse` as optional', () => {
+    const result = borderCollapse<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderCollapse<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/table/__tests__/borderSpacing.ts b/src/utils/table/__tests__/borderSpacing.ts
index b7861c4..393dcaa 100644
--- a/src/utils/table/__tests__/borderSpacing.ts
+++ b/src/utils/table/__tests__/borderSpacing.ts
@@ -24,6 +24,11 @@ describe('borderSpacing', () => {
     expect(result).toEqual({ borderSpacing: 'a' });
   });
 
+  it('should use an interface which marks `borderSpacing` as optional', () => {
+    const result = borderSpacing<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = borderSpacing<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/table/__tests__/captionSide.ts b/src/utils/table/__tests__/captionSide.ts
index 292c659..0291f8c 100644
--- a/src/utils/table/__tests__/captionSide.ts
+++ b/src/utils/table/__tests__/captionSide.ts
@@ -24,6 +24,11 @@ describe('captionSide', () => {
     expect(result).toEqual({ captionSide: 'a' });
   });
 
+  it('should use an interface which marks `captionSide` as optional', () => {
+    const result = captionSide<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = captionSide<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/table/__tests__/emptyCells.ts b/src/utils/table/__tests__/emptyCells.ts
index 3c1f6d1..6232863 100644
--- a/src/utils/table/__tests__/emptyCells.ts
+++ b/src/utils/table/__tests__/emptyCells.ts
@@ -24,6 +24,11 @@ describe('emptyCells', () => {
     expect(result).toEqual({ emptyCells: 'a' });
   });
 
+  it('should use an interface which marks `emptyCells` as optional', () => {
+    const result = emptyCells<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = emptyCells<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/table/__tests__/tableLayout.ts b/src/utils/table/__tests__/tableLayout.ts
index bd1d844..db0f173 100644
--- a/src/utils/table/__tests__/tableLayout.ts
+++ b/src/utils/table/__tests__/tableLayout.ts
@@ -24,6 +24,11 @@ describe('tableLayout', () => {
     expect(result).toEqual({ tableLayout: 'a' });
   });
 
+  it('should use an interface which marks `tableLayout` as optional', () => {
+    const result = tableLayout<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = tableLayout<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/table/__tests__/verticalAlign.ts b/src/utils/table/__tests__/verticalAlign.ts
index 7c2d82a..97d8772 100644
--- a/src/utils/table/__tests__/verticalAlign.ts
+++ b/src/utils/table/__tests__/verticalAlign.ts
@@ -24,6 +24,11 @@ describe('verticalAlign', () => {
     expect(result).toEqual({ verticalAlign: 'a' });
   });
 
+  it('should use an interface which marks `verticalAlign` as optional', () => {
+    const result = verticalAlign<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = verticalAlign<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textDecoration.ts b/src/utils/text-decoration/__tests__/textDecoration.ts
index a505cbc..aad4f4e 100644
--- a/src/utils/text-decoration/__tests__/textDecoration.ts
+++ b/src/utils/text-decoration/__tests__/textDecoration.ts
@@ -24,6 +24,11 @@ describe('textDecoration', () => {
     expect(result).toEqual({ textDecoration: 'a' });
   });
 
+  it('should use an interface which marks `textDecoration` as optional', () => {
+    const result = textDecoration<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textDecoration<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textDecorationColor.ts b/src/utils/text-decoration/__tests__/textDecorationColor.ts
index 1e96062..3afb535 100644
--- a/src/utils/text-decoration/__tests__/textDecorationColor.ts
+++ b/src/utils/text-decoration/__tests__/textDecorationColor.ts
@@ -24,6 +24,11 @@ describe('textDecorationColor', () => {
     expect(result).toEqual({ textDecorationColor: 'a' });
   });
 
+  it('should use an interface which marks `textDecorationColor` as optional', () => {
+    const result = textDecorationColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textDecorationColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textDecorationLine.ts b/src/utils/text-decoration/__tests__/textDecorationLine.ts
index 380229b..2800b0f 100644
--- a/src/utils/text-decoration/__tests__/textDecorationLine.ts
+++ b/src/utils/text-decoration/__tests__/textDecorationLine.ts
@@ -24,6 +24,11 @@ describe('textDecorationLine', () => {
     expect(result).toEqual({ textDecorationLine: 'a' });
   });
 
+  it('should use an interface which marks `textDecorationLine` as optional', () => {
+    const result = textDecorationLine<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textDecorationLine<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textDecorationStyle.ts b/src/utils/text-decoration/__tests__/textDecorationStyle.ts
index 76889fa..c208d30 100644
--- a/src/utils/text-decoration/__tests__/textDecorationStyle.ts
+++ b/src/utils/text-decoration/__tests__/textDecorationStyle.ts
@@ -24,6 +24,11 @@ describe('textDecorationStyle', () => {
     expect(result).toEqual({ textDecorationStyle: 'a' });
   });
 
+  it('should use an interface which marks `textDecorationStyle` as optional', () => {
+    const result = textDecorationStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textDecorationStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textEmphasis.ts b/src/utils/text-decoration/__tests__/textEmphasis.ts
index 7e66d40..4202f30 100644
--- a/src/utils/text-decoration/__tests__/textEmphasis.ts
+++ b/src/utils/text-decoration/__tests__/textEmphasis.ts
@@ -24,6 +24,11 @@ describe('textEmphasis', () => {
     expect(result).toEqual({ textEmphasis: 'a' });
   });
 
+  it('should use an interface which marks `textEmphasis` as optional', () => {
+    const result = textEmphasis<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textEmphasis<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textEmphasisColor.ts b/src/utils/text-decoration/__tests__/textEmphasisColor.ts
index b0efafb..f56adc5 100644
--- a/src/utils/text-decoration/__tests__/textEmphasisColor.ts
+++ b/src/utils/text-decoration/__tests__/textEmphasisColor.ts
@@ -24,6 +24,11 @@ describe('textEmphasisColor', () => {
     expect(result).toEqual({ textEmphasisColor: 'a' });
   });
 
+  it('should use an interface which marks `textEmphasisColor` as optional', () => {
+    const result = textEmphasisColor<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textEmphasisColor<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textEmphasisPosition.ts b/src/utils/text-decoration/__tests__/textEmphasisPosition.ts
index 0f80c87..4022302 100644
--- a/src/utils/text-decoration/__tests__/textEmphasisPosition.ts
+++ b/src/utils/text-decoration/__tests__/textEmphasisPosition.ts
@@ -24,6 +24,11 @@ describe('textEmphasisPosition', () => {
     expect(result).toEqual({ textEmphasisPosition: 'a' });
   });
 
+  it('should use an interface which marks `textEmphasisPosition` as optional', () => {
+    const result = textEmphasisPosition<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textEmphasisPosition<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textEmphasisStyle.ts b/src/utils/text-decoration/__tests__/textEmphasisStyle.ts
index c5aded0..8808cdb 100644
--- a/src/utils/text-decoration/__tests__/textEmphasisStyle.ts
+++ b/src/utils/text-decoration/__tests__/textEmphasisStyle.ts
@@ -24,6 +24,11 @@ describe('textEmphasisStyle', () => {
     expect(result).toEqual({ textEmphasisStyle: 'a' });
   });
 
+  it('should use an interface which marks `textEmphasisStyle` as optional', () => {
+    const result = textEmphasisStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textEmphasisStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textShadow.ts b/src/utils/text-decoration/__tests__/textShadow.ts
index 34df5da..9a57333 100644
--- a/src/utils/text-decoration/__tests__/textShadow.ts
+++ b/src/utils/text-decoration/__tests__/textShadow.ts
@@ -24,6 +24,11 @@ describe('textShadow', () => {
     expect(result).toEqual({ textShadow: 'a' });
   });
 
+  it('should use an interface which marks `textShadow` as optional', () => {
+    const result = textShadow<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textShadow<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text-decoration/__tests__/textUnderlinePosition.ts b/src/utils/text-decoration/__tests__/textUnderlinePosition.ts
index 216164c..9c1e5a5 100644
--- a/src/utils/text-decoration/__tests__/textUnderlinePosition.ts
+++ b/src/utils/text-decoration/__tests__/textUnderlinePosition.ts
@@ -24,6 +24,11 @@ describe('textUnderlinePosition', () => {
     expect(result).toEqual({ textUnderlinePosition: 'a' });
   });
 
+  it('should use an interface which marks `textUnderlinePosition` as optional', () => {
+    const result = textUnderlinePosition<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textUnderlinePosition<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/hangingPunctuation.ts b/src/utils/text/__tests__/hangingPunctuation.ts
index 4abd264..085ec6f 100644
--- a/src/utils/text/__tests__/hangingPunctuation.ts
+++ b/src/utils/text/__tests__/hangingPunctuation.ts
@@ -24,6 +24,11 @@ describe('hangingPunctuation', () => {
     expect(result).toEqual({ hangingPunctuation: 'a' });
   });
 
+  it('should use an interface which marks `hangingPunctuation` as optional', () => {
+    const result = hangingPunctuation<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = hangingPunctuation<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/hyphens.ts b/src/utils/text/__tests__/hyphens.ts
index 6be6a50..1fa46f0 100644
--- a/src/utils/text/__tests__/hyphens.ts
+++ b/src/utils/text/__tests__/hyphens.ts
@@ -24,6 +24,11 @@ describe('hyphens', () => {
     expect(result).toEqual({ hyphens: 'a' });
   });
 
+  it('should use an interface which marks `hyphens` as optional', () => {
+    const result = hyphens<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = hyphens<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/letterSpacing.ts b/src/utils/text/__tests__/letterSpacing.ts
index a96839a..93ca343 100644
--- a/src/utils/text/__tests__/letterSpacing.ts
+++ b/src/utils/text/__tests__/letterSpacing.ts
@@ -24,6 +24,11 @@ describe('letterSpacing', () => {
     expect(result).toEqual({ letterSpacing: 'a' });
   });
 
+  it('should use an interface which marks `letterSpacing` as optional', () => {
+    const result = letterSpacing<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = letterSpacing<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/lineBreak.ts b/src/utils/text/__tests__/lineBreak.ts
index 156a6bd..2cc9ade 100644
--- a/src/utils/text/__tests__/lineBreak.ts
+++ b/src/utils/text/__tests__/lineBreak.ts
@@ -24,6 +24,11 @@ describe('lineBreak', () => {
     expect(result).toEqual({ lineBreak: 'a' });
   });
 
+  it('should use an interface which marks `lineBreak` as optional', () => {
+    const result = lineBreak<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = lineBreak<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/overflowWrap.ts b/src/utils/text/__tests__/overflowWrap.ts
index f5aef94..c7776b2 100644
--- a/src/utils/text/__tests__/overflowWrap.ts
+++ b/src/utils/text/__tests__/overflowWrap.ts
@@ -24,6 +24,11 @@ describe('overflowWrap', () => {
     expect(result).toEqual({ overflowWrap: 'a' });
   });
 
+  it('should use an interface which marks `overflowWrap` as optional', () => {
+    const result = overflowWrap<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = overflowWrap<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/tabSize.ts b/src/utils/text/__tests__/tabSize.ts
index a291b30..f8d464b 100644
--- a/src/utils/text/__tests__/tabSize.ts
+++ b/src/utils/text/__tests__/tabSize.ts
@@ -24,6 +24,11 @@ describe('tabSize', () => {
     expect(result).toEqual({ tabSize: 'a' });
   });
 
+  it('should use an interface which marks `tabSize` as optional', () => {
+    const result = tabSize<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = tabSize<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/textAlign.ts b/src/utils/text/__tests__/textAlign.ts
index 9f5f91d..1b1143f 100644
--- a/src/utils/text/__tests__/textAlign.ts
+++ b/src/utils/text/__tests__/textAlign.ts
@@ -24,6 +24,11 @@ describe('textAlign', () => {
     expect(result).toEqual({ textAlign: 'a' });
   });
 
+  it('should use an interface which marks `textAlign` as optional', () => {
+    const result = textAlign<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textAlign<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/textAlignLast.ts b/src/utils/text/__tests__/textAlignLast.ts
index e206e2f..692cd57 100644
--- a/src/utils/text/__tests__/textAlignLast.ts
+++ b/src/utils/text/__tests__/textAlignLast.ts
@@ -24,6 +24,11 @@ describe('textAlignLast', () => {
     expect(result).toEqual({ textAlignLast: 'a' });
   });
 
+  it('should use an interface which marks `textAlignLast` as optional', () => {
+    const result = textAlignLast<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textAlignLast<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/textIndent.ts b/src/utils/text/__tests__/textIndent.ts
index 2d74712..93dd9c7 100644
--- a/src/utils/text/__tests__/textIndent.ts
+++ b/src/utils/text/__tests__/textIndent.ts
@@ -24,6 +24,11 @@ describe('textIndent', () => {
     expect(result).toEqual({ textIndent: 'a' });
   });
 
+  it('should use an interface which marks `textIndent` as optional', () => {
+    const result = textIndent<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textIndent<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/textJustify.ts b/src/utils/text/__tests__/textJustify.ts
index 16b772c..f2ce45d 100644
--- a/src/utils/text/__tests__/textJustify.ts
+++ b/src/utils/text/__tests__/textJustify.ts
@@ -24,6 +24,11 @@ describe('textJustify', () => {
     expect(result).toEqual({ textJustify: 'a' });
   });
 
+  it('should use an interface which marks `textJustify` as optional', () => {
+    const result = textJustify<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textJustify<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/textTransform.ts b/src/utils/text/__tests__/textTransform.ts
index 4e8d77c..11bb813 100644
--- a/src/utils/text/__tests__/textTransform.ts
+++ b/src/utils/text/__tests__/textTransform.ts
@@ -24,6 +24,11 @@ describe('textTransform', () => {
     expect(result).toEqual({ textTransform: 'a' });
   });
 
+  it('should use an interface which marks `textTransform` as optional', () => {
+    const result = textTransform<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textTransform<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/whiteSpace.ts b/src/utils/text/__tests__/whiteSpace.ts
index f434e77..f197f99 100644
--- a/src/utils/text/__tests__/whiteSpace.ts
+++ b/src/utils/text/__tests__/whiteSpace.ts
@@ -24,6 +24,11 @@ describe('whiteSpace', () => {
     expect(result).toEqual({ whiteSpace: 'a' });
   });
 
+  it('should use an interface which marks `whiteSpace` as optional', () => {
+    const result = whiteSpace<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = whiteSpace<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/wordBreak.ts b/src/utils/text/__tests__/wordBreak.ts
index 9b80e0a..5130469 100644
--- a/src/utils/text/__tests__/wordBreak.ts
+++ b/src/utils/text/__tests__/wordBreak.ts
@@ -24,6 +24,11 @@ describe('wordBreak', () => {
     expect(result).toEqual({ wordBreak: 'a' });
   });
 
+  it('should use an interface which marks `wordBreak` as optional', () => {
+    const result = wordBreak<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = wordBreak<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/wordSpacing.ts b/src/utils/text/__tests__/wordSpacing.ts
index 34685bf..2445ba4 100644
--- a/src/utils/text/__tests__/wordSpacing.ts
+++ b/src/utils/text/__tests__/wordSpacing.ts
@@ -24,6 +24,11 @@ describe('wordSpacing', () => {
     expect(result).toEqual({ wordSpacing: 'a' });
   });
 
+  it('should use an interface which marks `wordSpacing` as optional', () => {
+    const result = wordSpacing<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = wordSpacing<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/text/__tests__/wordWrap.ts b/src/utils/text/__tests__/wordWrap.ts
index b2542b6..6dada5d 100644
--- a/src/utils/text/__tests__/wordWrap.ts
+++ b/src/utils/text/__tests__/wordWrap.ts
@@ -24,6 +24,11 @@ describe('wordWrap', () => {
     expect(result).toEqual({ wordWrap: 'a' });
   });
 
+  it('should use an interface which marks `wordWrap` as optional', () => {
+    const result = wordWrap<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = wordWrap<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/backfaceVisibility.ts b/src/utils/transforms/__tests__/backfaceVisibility.ts
index 765cba0..0ee8db8 100644
--- a/src/utils/transforms/__tests__/backfaceVisibility.ts
+++ b/src/utils/transforms/__tests__/backfaceVisibility.ts
@@ -24,6 +24,11 @@ describe('backfaceVisibility', () => {
     expect(result).toEqual({ backfaceVisibility: 'a' });
   });
 
+  it('should use an interface which marks `backfaceVisibility` as optional', () => {
+    const result = backfaceVisibility<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = backfaceVisibility<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/perspective.ts b/src/utils/transforms/__tests__/perspective.ts
index 5ff1c2f..ab20f2c 100644
--- a/src/utils/transforms/__tests__/perspective.ts
+++ b/src/utils/transforms/__tests__/perspective.ts
@@ -24,6 +24,11 @@ describe('perspective', () => {
     expect(result).toEqual({ perspective: 'a' });
   });
 
+  it('should use an interface which marks `perspective` as optional', () => {
+    const result = perspective<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = perspective<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/perspectiveOrigin.ts b/src/utils/transforms/__tests__/perspectiveOrigin.ts
index fe01980..7dfa6c4 100644
--- a/src/utils/transforms/__tests__/perspectiveOrigin.ts
+++ b/src/utils/transforms/__tests__/perspectiveOrigin.ts
@@ -24,6 +24,11 @@ describe('perspectiveOrigin', () => {
     expect(result).toEqual({ perspectiveOrigin: 'a' });
   });
 
+  it('should use an interface which marks `perspectiveOrigin` as optional', () => {
+    const result = perspectiveOrigin<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = perspectiveOrigin<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/rotate.ts b/src/utils/transforms/__tests__/rotate.ts
index 1b369a2..69f33b9 100644
--- a/src/utils/transforms/__tests__/rotate.ts
+++ b/src/utils/transforms/__tests__/rotate.ts
@@ -24,6 +24,11 @@ describe('rotate', () => {
     expect(result).toEqual({ rotate: 'a' });
   });
 
+  it('should use an interface which marks `rotate` as optional', () => {
+    const result = rotate<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = rotate<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/scale.ts b/src/utils/transforms/__tests__/scale.ts
index 054ab15..6ea572d 100644
--- a/src/utils/transforms/__tests__/scale.ts
+++ b/src/utils/transforms/__tests__/scale.ts
@@ -24,6 +24,11 @@ describe('scale', () => {
     expect(result).toEqual({ scale: 'a' });
   });
 
+  it('should use an interface which marks `scale` as optional', () => {
+    const result = scale<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = scale<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/transform.ts b/src/utils/transforms/__tests__/transform.ts
index 9692402..1741f99 100644
--- a/src/utils/transforms/__tests__/transform.ts
+++ b/src/utils/transforms/__tests__/transform.ts
@@ -24,6 +24,11 @@ describe('transform', () => {
     expect(result).toEqual({ transform: 'a' });
   });
 
+  it('should use an interface which marks `transform` as optional', () => {
+    const result = transform<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = transform<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/transformBox.ts b/src/utils/transforms/__tests__/transformBox.ts
index c94f344..88fff4f 100644
--- a/src/utils/transforms/__tests__/transformBox.ts
+++ b/src/utils/transforms/__tests__/transformBox.ts
@@ -24,6 +24,11 @@ describe('transformBox', () => {
     expect(result).toEqual({ transformBox: 'a' });
   });
 
+  it('should use an interface which marks `transformBox` as optional', () => {
+    const result = transformBox<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = transformBox<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/transformOrigin.ts b/src/utils/transforms/__tests__/transformOrigin.ts
index be2f724..aa0a361 100644
--- a/src/utils/transforms/__tests__/transformOrigin.ts
+++ b/src/utils/transforms/__tests__/transformOrigin.ts
@@ -24,6 +24,11 @@ describe('transformOrigin', () => {
     expect(result).toEqual({ transformOrigin: 'a' });
   });
 
+  it('should use an interface which marks `transformOrigin` as optional', () => {
+    const result = transformOrigin<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = transformOrigin<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/transformStyle.ts b/src/utils/transforms/__tests__/transformStyle.ts
index a7c094b..6e36c30 100644
--- a/src/utils/transforms/__tests__/transformStyle.ts
+++ b/src/utils/transforms/__tests__/transformStyle.ts
@@ -24,6 +24,11 @@ describe('transformStyle', () => {
     expect(result).toEqual({ transformStyle: 'a' });
   });
 
+  it('should use an interface which marks `transformStyle` as optional', () => {
+    const result = transformStyle<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = transformStyle<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transforms/__tests__/translate.ts b/src/utils/transforms/__tests__/translate.ts
index 58989d3..1cde8de 100644
--- a/src/utils/transforms/__tests__/translate.ts
+++ b/src/utils/transforms/__tests__/translate.ts
@@ -24,6 +24,11 @@ describe('translate', () => {
     expect(result).toEqual({ translate: 'a' });
   });
 
+  it('should use an interface which marks `translate` as optional', () => {
+    const result = translate<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = translate<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transitions/__tests__/transition.ts b/src/utils/transitions/__tests__/transition.ts
index b5478c6..43b7323 100644
--- a/src/utils/transitions/__tests__/transition.ts
+++ b/src/utils/transitions/__tests__/transition.ts
@@ -24,6 +24,11 @@ describe('transition', () => {
     expect(result).toEqual({ transition: 'a' });
   });
 
+  it('should use an interface which marks `transition` as optional', () => {
+    const result = transition<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = transition<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transitions/__tests__/transitionDelay.ts b/src/utils/transitions/__tests__/transitionDelay.ts
index d159acb..484c477 100644
--- a/src/utils/transitions/__tests__/transitionDelay.ts
+++ b/src/utils/transitions/__tests__/transitionDelay.ts
@@ -24,6 +24,11 @@ describe('transitionDelay', () => {
     expect(result).toEqual({ transitionDelay: 'a' });
   });
 
+  it('should use an interface which marks `transitionDelay` as optional', () => {
+    const result = transitionDelay<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = transitionDelay<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transitions/__tests__/transitionDuration.ts b/src/utils/transitions/__tests__/transitionDuration.ts
index 4ab85d5..3233cbb 100644
--- a/src/utils/transitions/__tests__/transitionDuration.ts
+++ b/src/utils/transitions/__tests__/transitionDuration.ts
@@ -24,6 +24,11 @@ describe('transitionDuration', () => {
     expect(result).toEqual({ transitionDuration: 'a' });
   });
 
+  it('should use an interface which marks `transitionDuration` as optional', () => {
+    const result = transitionDuration<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = transitionDuration<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transitions/__tests__/transitionProperty.ts b/src/utils/transitions/__tests__/transitionProperty.ts
index f41aa93..6e24b3d 100644
--- a/src/utils/transitions/__tests__/transitionProperty.ts
+++ b/src/utils/transitions/__tests__/transitionProperty.ts
@@ -24,6 +24,11 @@ describe('transitionProperty', () => {
     expect(result).toEqual({ transitionProperty: 'a' });
   });
 
+  it('should use an interface which marks `transitionProperty` as optional', () => {
+    const result = transitionProperty<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = transitionProperty<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/transitions/__tests__/transitionTimingFunction.ts b/src/utils/transitions/__tests__/transitionTimingFunction.ts
index 6fc56b8..c03d5f5 100644
--- a/src/utils/transitions/__tests__/transitionTimingFunction.ts
+++ b/src/utils/transitions/__tests__/transitionTimingFunction.ts
@@ -24,6 +24,11 @@ describe('transitionTimingFunction', () => {
     expect(result).toEqual({ transitionTimingFunction: 'a' });
   });
 
+  it('should use an interface which marks `transitionTimingFunction` as optional', () => {
+    const result = transitionTimingFunction<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = transitionTimingFunction<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/will-change/__tests__/willChange.ts b/src/utils/will-change/__tests__/willChange.ts
index 28004b5..881a5ab 100644
--- a/src/utils/will-change/__tests__/willChange.ts
+++ b/src/utils/will-change/__tests__/willChange.ts
@@ -24,6 +24,11 @@ describe('willChange', () => {
     expect(result).toEqual({ willChange: 'a' });
   });
 
+  it('should use an interface which marks `willChange` as optional', () => {
+    const result = willChange<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = willChange<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/writing-modes/__tests__/direction.ts b/src/utils/writing-modes/__tests__/direction.ts
index ce39491..cf1d3f1 100644
--- a/src/utils/writing-modes/__tests__/direction.ts
+++ b/src/utils/writing-modes/__tests__/direction.ts
@@ -24,6 +24,11 @@ describe('direction', () => {
     expect(result).toEqual({ direction: 'a' });
   });
 
+  it('should use an interface which marks `direction` as optional', () => {
+    const result = direction<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = direction<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/writing-modes/__tests__/textCombineUpright.ts b/src/utils/writing-modes/__tests__/textCombineUpright.ts
index d765e62..00f0916 100644
--- a/src/utils/writing-modes/__tests__/textCombineUpright.ts
+++ b/src/utils/writing-modes/__tests__/textCombineUpright.ts
@@ -24,6 +24,11 @@ describe('textCombineUpright', () => {
     expect(result).toEqual({ textCombineUpright: 'a' });
   });
 
+  it('should use an interface which marks `textCombineUpright` as optional', () => {
+    const result = textCombineUpright<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textCombineUpright<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/writing-modes/__tests__/textOrientation.ts b/src/utils/writing-modes/__tests__/textOrientation.ts
index ff11cbb..39085ae 100644
--- a/src/utils/writing-modes/__tests__/textOrientation.ts
+++ b/src/utils/writing-modes/__tests__/textOrientation.ts
@@ -24,6 +24,11 @@ describe('textOrientation', () => {
     expect(result).toEqual({ textOrientation: 'a' });
   });
 
+  it('should use an interface which marks `textOrientation` as optional', () => {
+    const result = textOrientation<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = textOrientation<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/writing-modes/__tests__/unicodeBidi.ts b/src/utils/writing-modes/__tests__/unicodeBidi.ts
index a6d4ddf..35f4abd 100644
--- a/src/utils/writing-modes/__tests__/unicodeBidi.ts
+++ b/src/utils/writing-modes/__tests__/unicodeBidi.ts
@@ -24,6 +24,11 @@ describe('unicodeBidi', () => {
     expect(result).toEqual({ unicodeBidi: 'a' });
   });
 
+  it('should use an interface which marks `unicodeBidi` as optional', () => {
+    const result = unicodeBidi<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = unicodeBidi<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/src/utils/writing-modes/__tests__/writingMode.ts b/src/utils/writing-modes/__tests__/writingMode.ts
index 04a1c1c..a9d8a60 100644
--- a/src/utils/writing-modes/__tests__/writingMode.ts
+++ b/src/utils/writing-modes/__tests__/writingMode.ts
@@ -24,6 +24,11 @@ describe('writingMode', () => {
     expect(result).toEqual({ writingMode: 'a' });
   });
 
+  it('should use an interface which marks `writingMode` as optional', () => {
+    const result = writingMode<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = writingMode<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',
diff --git a/util-test-template.txt b/util-test-template.txt
index f530290..dc9225d 100644
--- a/util-test-template.txt
+++ b/util-test-template.txt
@@ -24,6 +24,11 @@ describe('__PROPERTY_NAME__', () => {
     expect(result).toEqual({ __PROPERTY_NAME__: 'a' });
   });
 
+  it('should use an interface which marks `__PROPERTY_NAME__` as optional', () => {
+    const result = __PROPERTY_NAME__<'a'>()({});
+    expect(result).toEqual(undefined);
+  });
+
   it('should allow using a theme', () => {
     const result = __PROPERTY_NAME__<'value', IThemeWithoutBreakpoints>({
       themeProp: 'dummy',