@makeswift/prop-controllers 0.1.0-canary.4 → 0.1.0-canary.5

package/dist/index.cjs

@@ -28,6 +28,8 @@ __export(src_exports, {
   ControlDataTypeKey: () => ControlDataTypeKey,
   Date: () => Date,
   Font: () => Font,
+  GapX: () => GapX,
+  GapY: () => GapY,
   Link: () => Link,
   Margin: () => Margin,
   MarginPropControllerFormat: () => MarginPropControllerFormat,
@@ -40,6 +42,7 @@ __export(src_exports, {
   ResponsiveLengthPropControllerDataV1Type: () => ResponsiveLengthPropControllerDataV1Type,
   Shadows: () => Shadows,
   Table: () => Table,
+  TextArea: () => TextArea,
   TextStyle: () => TextStyle,
   Types: () => Types,
   Video: () => Video,
@@ -59,6 +62,8 @@ __export(src_exports, {
   createCheckboxPropControllerDataFromBoolean: () => createCheckboxPropControllerDataFromBoolean,
   createDatePropControllerDataFromString: () => createDatePropControllerDataFromString,
   createFontPropControllerDataFromResponsiveFontData: () => createFontPropControllerDataFromResponsiveFontData,
+  createGapXPropControllerDataFromResponsiveGapData: () => createGapXPropControllerDataFromResponsiveGapData,
+  createGapYPropControllerDataFromResponsiveGapData: () => createGapYPropControllerDataFromResponsiveGapData,
   createLinkPropControllerDataFromLinkData: () => createLinkPropControllerDataFromLinkData,
   createMarginPropControllerDataFromResponsiveMarginData: () => createMarginPropControllerDataFromResponsiveMarginData,
   createNavigationLinksPropControllerDataFromNavigationLinksData: () => createNavigationLinksPropControllerDataFromNavigationLinksData,
@@ -69,17 +74,22 @@ __export(src_exports, {
   createResponsiveValueSchema: () => createResponsiveValueSchema,
   createShadowsPropControllerDataFromResponsiveShadowsData: () => createShadowsPropControllerDataFromResponsiveShadowsData,
   createTablePropControllerDataFromTableId: () => createTablePropControllerDataFromTableId,
+  createTextAreaPropControllerDataFromString: () => createTextAreaPropControllerDataFromString,
   createTextStylePropControllerDataFromResponsiveTextStyleData: () => createTextStylePropControllerDataFromResponsiveTextStyleData,
   createVideoPropControllerDataFromVideoData: () => createVideoPropControllerDataFromVideoData,
   createWidthPropControllerDataFromResponsiveLengthData: () => createWidthPropControllerDataFromResponsiveLengthData,
   datePropControllerDataSchema: () => datePropControllerDataSchema,
   fontPropControllerDataSchema: () => fontPropControllerDataSchema,
+  gapXPropControllerDataSchema: () => gapXPropControllerDataSchema,
+  gapYPropControllerDataSchema: () => gapYPropControllerDataSchema,
   getBorderPropControllerDataResponsiveBorderData: () => getBorderPropControllerDataResponsiveBorderData,
   getBorderPropControllerDataSwatchIds: () => getBorderPropControllerDataSwatchIds,
   getBorderRadiusPropControllerDataResponsiveBorderRadiusData: () => getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
   getCheckboxPropControllerDataBoolean: () => getCheckboxPropControllerDataBoolean,
   getDatePropControllerDataString: () => getDatePropControllerDataString,
   getFontPropControllerDataResponsiveFontData: () => getFontPropControllerDataResponsiveFontData,
+  getGapXPropControllerDataResponsiveGapData: () => getGapXPropControllerDataResponsiveGapData,
+  getGapYPropControllerDataResponsiveGapData: () => getGapYPropControllerDataResponsiveGapData,
   getLinkPropControllerDataLinkData: () => getLinkPropControllerDataLinkData,
   getLinkPropControllerPageIds: () => getLinkPropControllerPageIds,
   getMarginPropControllerDataResponsiveMarginData: () => getMarginPropControllerDataResponsiveMarginData,
@@ -96,6 +106,7 @@ __export(src_exports, {
   getShadowsPropControllerDataSwatchIds: () => getShadowsPropControllerDataSwatchIds,
   getTablePropControllerDataTableId: () => getTablePropControllerDataTableId,
   getTablePropControllerDataTableIds: () => getTablePropControllerDataTableIds,
+  getTextAreaPropControllerDataString: () => getTextAreaPropControllerDataString,
   getTextStylePropControllerDataResponsiveTextStyleData: () => getTextStylePropControllerDataResponsiveTextStyleData,
   getVideoPropControllerDataVideoData: () => getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData: () => getWidthPropControllerDataResponsiveLengthData,
@@ -109,6 +120,7 @@ __export(src_exports, {
   responsiveLengthPropControllerDataSchema: () => responsiveLengthPropControllerDataSchema,
   shadowsPropControllerDataSchema: () => shadowsPropControllerDataSchema,
   tablePropControllerDataSchema: () => tablePropControllerDataSchema,
+  textAreaPropControllerDataSchema: () => textAreaPropControllerDataSchema,
   textStylePropControllerDataSchema: () => textStylePropControllerDataSchema,
   videoPropControllerDataSchema: () => videoPropControllerDataSchema,
   widthPropControllerDataSchema: () => widthPropControllerDataSchema
@@ -123,6 +135,8 @@ var Types = {
   Checkbox: "Checkbox",
   Date: "Date",
   Font: "Font",
+  GapX: "GapX",
+  GapY: "GapY",
   Link: "Link",
   Margin: "Margin",
   NavigationLinks: "NavigationLinks",
@@ -131,6 +145,7 @@ var Types = {
   Shadows: "Shadows",
   ResponsiveColor: "ResponsiveColor",
   ResponsiveLength: "ResponsiveLength",
+  TextArea: "TextArea",
   Table: "Table",
   TextStyle: "TextStyle",
   Width: "Width",
@@ -161,6 +176,11 @@ var lengthDataSchema = import_zod2.z.object({
   value: import_zod2.z.number(),
   unit: import_zod2.z.union([import_zod2.z.literal("px"), import_zod2.z.literal("%")])
 });
+var gapDataSchema = import_zod2.z.object({
+  value: import_zod2.z.number(),
+  unit: import_zod2.z.literal("px")
+});
+var responsiveGapDataSchema = createResponsiveValueSchema(gapDataSchema);
 
 // src/border/border.ts
 var import_zod3 = require("zod");
@@ -417,58 +437,122 @@ function createFontPropControllerDataFromResponsiveFontData(responsiveFontData,
   ).otherwise(() => responsiveFontData);
 }
 
-// src/link/link.ts
+// src/gap-x/gap-x.ts
 var import_ts_pattern6 = require("ts-pattern");
 var import_zod8 = require("zod");
-var openPageLinkSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("OPEN_PAGE"),
-  payload: import_zod8.z.object({
-    pageId: import_zod8.z.string().nullable().optional(),
-    openInNewTab: import_zod8.z.boolean()
+var gapXPropControllerDataV0Schema = responsiveGapDataSchema;
+var GapXPropControllerDataV1Type = "prop-controllers::gap-x::v1";
+var gapXPropControllerDataV1Schema = import_zod8.z.object({
+  [ControlDataTypeKey]: import_zod8.z.literal(GapXPropControllerDataV1Type),
+  value: responsiveGapDataSchema
+});
+var gapXPropControllerDataSchema = import_zod8.z.union([
+  gapXPropControllerDataV0Schema,
+  gapXPropControllerDataV1Schema
+]);
+function GapX(options = {}) {
+  return { type: Types.GapX, version: 1, options };
+}
+function getGapXPropControllerDataResponsiveGapData(data) {
+  return (0, import_ts_pattern6.match)(data).with(
+    { [ControlDataTypeKey]: GapXPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createGapXPropControllerDataFromResponsiveGapData(responsiveGapData, definition) {
+  return (0, import_ts_pattern6.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: GapXPropControllerDataV1Type,
+      value: responsiveGapData
+    })
+  ).otherwise(() => responsiveGapData);
+}
+
+// src/gap-y/gap-y.ts
+var import_ts_pattern7 = require("ts-pattern");
+var import_zod9 = require("zod");
+var gapYPropControllerDataV0Schema = responsiveGapDataSchema;
+var GapYPropControllerDataV1Type = "prop-controllers::gap-y::v1";
+var gapYPropControllerDataV1Schema = import_zod9.z.object({
+  [ControlDataTypeKey]: import_zod9.z.literal(GapYPropControllerDataV1Type),
+  value: responsiveGapDataSchema
+});
+var gapYPropControllerDataSchema = import_zod9.z.union([
+  gapYPropControllerDataV0Schema,
+  gapYPropControllerDataV1Schema
+]);
+function GapY(options = {}) {
+  return { type: Types.GapY, version: 1, options };
+}
+function getGapYPropControllerDataResponsiveGapData(data) {
+  return (0, import_ts_pattern7.match)(data).with(
+    { [ControlDataTypeKey]: GapYPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createGapYPropControllerDataFromResponsiveGapData(responsiveGapData, definition) {
+  return (0, import_ts_pattern7.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: GapYPropControllerDataV1Type,
+      value: responsiveGapData
+    })
+  ).otherwise(() => responsiveGapData);
+}
+
+// src/link/link.ts
+var import_ts_pattern8 = require("ts-pattern");
+var import_zod10 = require("zod");
+var openPageLinkSchema = import_zod10.z.object({
+  type: import_zod10.z.literal("OPEN_PAGE"),
+  payload: import_zod10.z.object({
+    pageId: import_zod10.z.string().nullable().optional(),
+    openInNewTab: import_zod10.z.boolean()
   }).transform((v) => ({
     pageId: v.pageId,
     ...v
   }))
 });
-var openURLLinkSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("OPEN_URL"),
-  payload: import_zod8.z.object({
-    url: import_zod8.z.string(),
-    openInNewTab: import_zod8.z.boolean()
+var openURLLinkSchema = import_zod10.z.object({
+  type: import_zod10.z.literal("OPEN_URL"),
+  payload: import_zod10.z.object({
+    url: import_zod10.z.string(),
+    openInNewTab: import_zod10.z.boolean()
   })
 });
-var sendEmailLinkSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("SEND_EMAIL"),
-  payload: import_zod8.z.object({
-    to: import_zod8.z.string(),
-    subject: import_zod8.z.string().optional(),
-    body: import_zod8.z.string().optional()
+var sendEmailLinkSchema = import_zod10.z.object({
+  type: import_zod10.z.literal("SEND_EMAIL"),
+  payload: import_zod10.z.object({
+    to: import_zod10.z.string(),
+    subject: import_zod10.z.string().optional(),
+    body: import_zod10.z.string().optional()
   })
 });
-var callPhoneLinkSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("CALL_PHONE"),
-  payload: import_zod8.z.object({
-    phoneNumber: import_zod8.z.string()
+var callPhoneLinkSchema = import_zod10.z.object({
+  type: import_zod10.z.literal("CALL_PHONE"),
+  payload: import_zod10.z.object({
+    phoneNumber: import_zod10.z.string()
   })
 });
-var scrollToElementLinkSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("SCROLL_TO_ELEMENT"),
-  payload: import_zod8.z.object({
-    elementIdConfig: import_zod8.z.object({
-      elementKey: import_zod8.z.string(),
-      propName: import_zod8.z.string()
+var scrollToElementLinkSchema = import_zod10.z.object({
+  type: import_zod10.z.literal("SCROLL_TO_ELEMENT"),
+  payload: import_zod10.z.object({
+    elementIdConfig: import_zod10.z.object({
+      elementKey: import_zod10.z.string(),
+      propName: import_zod10.z.string()
     }).nullable().optional(),
-    block: import_zod8.z.union([
-      import_zod8.z.literal("start"),
-      import_zod8.z.literal("center"),
-      import_zod8.z.literal("end")
+    block: import_zod10.z.union([
+      import_zod10.z.literal("start"),
+      import_zod10.z.literal("center"),
+      import_zod10.z.literal("end")
     ])
   }).transform((v) => ({
     elementIdConfig: v.elementIdConfig,
     ...v
   }))
 });
-var linkDataSchema = import_zod8.z.union([
+var linkDataSchema = import_zod10.z.union([
   openPageLinkSchema,
   openURLLinkSchema,
   sendEmailLinkSchema,
@@ -477,11 +561,11 @@ var linkDataSchema = import_zod8.z.union([
 ]);
 var linkPropControllerDataV0Schema = linkDataSchema;
 var LinkPropControllerDataV1Type = "prop-controllers::link::v1";
-var linkPropControllerDataV1Schema = import_zod8.z.object({
-  [ControlDataTypeKey]: import_zod8.z.literal(LinkPropControllerDataV1Type),
+var linkPropControllerDataV1Schema = import_zod10.z.object({
+  [ControlDataTypeKey]: import_zod10.z.literal(LinkPropControllerDataV1Type),
   value: linkDataSchema
 });
-var linkPropControllerDataSchema = import_zod8.z.union([
+var linkPropControllerDataSchema = import_zod10.z.union([
   linkPropControllerDataV0Schema,
   linkPropControllerDataV1Schema
 ]);
@@ -489,13 +573,13 @@ function Link(options = {}) {
   return { type: Types.Link, version: 1, options };
 }
 function getLinkPropControllerDataLinkData(data) {
-  return (0, import_ts_pattern6.match)(data).with(
+  return (0, import_ts_pattern8.match)(data).with(
     { [ControlDataTypeKey]: LinkPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createLinkPropControllerDataFromLinkData(value, definition) {
-  return (0, import_ts_pattern6.match)(definition).with(
+  return (0, import_ts_pattern8.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: LinkPropControllerDataV1Type,
@@ -558,23 +642,23 @@ function copyLinkPropControllerData(data, context) {
   const value = copyLinkData(getLinkPropControllerDataLinkData(data), context);
   if (value == null)
     return value;
-  return (0, import_ts_pattern6.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
+  return (0, import_ts_pattern8.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
     ...v1,
     value
   })).otherwise((_) => value);
 }
 
 // src/margin/margin.ts
-var import_ts_pattern7 = require("ts-pattern");
-var import_zod9 = require("zod");
-var marginSideDataSchema = import_zod9.z.union([
-  import_zod9.z.object({
-    value: import_zod9.z.number(),
-    unit: import_zod9.z.literal("px")
+var import_ts_pattern9 = require("ts-pattern");
+var import_zod11 = require("zod");
+var marginSideDataSchema = import_zod11.z.union([
+  import_zod11.z.object({
+    value: import_zod11.z.number(),
+    unit: import_zod11.z.literal("px")
   }),
-  import_zod9.z.literal("auto")
+  import_zod11.z.literal("auto")
 ]);
-var marginDataSchema = import_zod9.z.object({
+var marginDataSchema = import_zod11.z.object({
   marginTop: marginSideDataSchema.nullable().optional(),
   marginRight: marginSideDataSchema.nullable().optional(),
   marginBottom: marginSideDataSchema.nullable().optional(),
@@ -588,11 +672,11 @@ var marginDataSchema = import_zod9.z.object({
 var responsiveMarginDataSchema = createResponsiveValueSchema(marginDataSchema);
 var marginPropControllerDataV0Schema = responsiveMarginDataSchema;
 var MarginPropControllerDataV1Type = "prop-controllers::margin::v1";
-var marginPropControllerDataV1Schema = import_zod9.z.object({
-  [ControlDataTypeKey]: import_zod9.z.literal(MarginPropControllerDataV1Type),
+var marginPropControllerDataV1Schema = import_zod11.z.object({
+  [ControlDataTypeKey]: import_zod11.z.literal(MarginPropControllerDataV1Type),
   value: responsiveMarginDataSchema
 });
-var marginPropControllerDataSchema = import_zod9.z.union([
+var marginPropControllerDataSchema = import_zod11.z.union([
   marginPropControllerDataV0Schema,
   marginPropControllerDataV1Schema
 ]);
@@ -605,15 +689,15 @@ function Margin(options = {}) {
 }
 Margin.Format = MarginPropControllerFormat;
 function getMarginPropControllerDataResponsiveMarginData(data) {
-  return (0, import_ts_pattern7.match)(data).with(
+  return (0, import_ts_pattern9.match)(data).with(
     { [ControlDataTypeKey]: MarginPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createMarginPropControllerDataFromResponsiveMarginData(responsiveMarginData, definition) {
-  return (0, import_ts_pattern7.match)(definition).with(
+  return (0, import_ts_pattern9.match)(definition).with(
     { version: 1 },
-    import_ts_pattern7.P.nullish,
+    import_ts_pattern9.P.nullish,
     () => ({
       [ControlDataTypeKey]: MarginPropControllerDataV1Type,
       value: responsiveMarginData
@@ -622,22 +706,22 @@ function createMarginPropControllerDataFromResponsiveMarginData(responsiveMargin
 }
 
 // src/navigation-links/navigation-links.ts
-var import_ts_pattern10 = require("ts-pattern");
-var import_zod12 = require("zod");
+var import_ts_pattern12 = require("ts-pattern");
+var import_zod14 = require("zod");
 
 // src/text-style/text-style.ts
-var import_ts_pattern8 = require("ts-pattern");
-var import_zod10 = require("zod");
-var textStyleDataSchema = import_zod10.z.object({
-  fontFamily: import_zod10.z.string().optional().nullable(),
-  letterSpacing: import_zod10.z.number().optional().nullable(),
-  fontSize: import_zod10.z.object({
-    value: import_zod10.z.number(),
-    unit: import_zod10.z.literal("px")
+var import_ts_pattern10 = require("ts-pattern");
+var import_zod12 = require("zod");
+var textStyleDataSchema = import_zod12.z.object({
+  fontFamily: import_zod12.z.string().optional().nullable(),
+  letterSpacing: import_zod12.z.number().optional().nullable(),
+  fontSize: import_zod12.z.object({
+    value: import_zod12.z.number(),
+    unit: import_zod12.z.literal("px")
   }).optional().nullable(),
-  fontWeight: import_zod10.z.number().optional().nullable(),
-  textTransform: import_zod10.z.array(import_zod10.z.literal("uppercase")),
-  fontStyle: import_zod10.z.array(import_zod10.z.literal("italic"))
+  fontWeight: import_zod12.z.number().optional().nullable(),
+  textTransform: import_zod12.z.array(import_zod12.z.literal("uppercase")),
+  fontStyle: import_zod12.z.array(import_zod12.z.literal("italic"))
 }).transform((v) => ({
   ...v,
   letterSpacing: v.letterSpacing,
@@ -649,11 +733,11 @@ var textStyleDataSchema = import_zod10.z.object({
 var responsiveTextStyleDataSchema = createResponsiveValueSchema(textStyleDataSchema);
 var textStylePropControllerDataV0Schema = responsiveTextStyleDataSchema;
 var TextStylePropControllerDataV1Type = "prop-controllers::text-style::v1";
-var textStylePropControllerDataV1Schema = import_zod10.z.object({
-  [ControlDataTypeKey]: import_zod10.z.literal(TextStylePropControllerDataV1Type),
+var textStylePropControllerDataV1Schema = import_zod12.z.object({
+  [ControlDataTypeKey]: import_zod12.z.literal(TextStylePropControllerDataV1Type),
   value: responsiveTextStyleDataSchema
 });
-var textStylePropControllerDataSchema = import_zod10.z.union([
+var textStylePropControllerDataSchema = import_zod12.z.union([
   textStylePropControllerDataV0Schema,
   textStylePropControllerDataV1Schema
 ]);
@@ -661,13 +745,13 @@ function TextStyle(options = {}) {
   return { type: Types.TextStyle, version: 1, options };
 }
 function getTextStylePropControllerDataResponsiveTextStyleData(data) {
-  return (0, import_ts_pattern8.match)(data).with(
+  return (0, import_ts_pattern10.match)(data).with(
     { [ControlDataTypeKey]: TextStylePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTextStylePropControllerDataFromResponsiveTextStyleData(responsiveTextStyleData, definition) {
-  return (0, import_ts_pattern8.match)(definition).with(
+  return (0, import_ts_pattern10.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: TextStylePropControllerDataV1Type,
@@ -677,16 +761,16 @@ function createTextStylePropControllerDataFromResponsiveTextStyleData(responsive
 }
 
 // src/responsive-color.ts
-var import_zod11 = require("zod");
-var import_ts_pattern9 = require("ts-pattern");
+var import_zod13 = require("zod");
+var import_ts_pattern11 = require("ts-pattern");
 var responsiveColorDataSchema = createResponsiveValueSchema(colorDataSchema);
 var responsiveColorPropControllerDataV0Schema = responsiveColorDataSchema;
 var ResponsiveColorPropControllerDataV1Type = "prop-controllers::responsive-color::v1";
-var responsiveColorPropControllerDataV1Schema = import_zod11.z.object({
-  [ControlDataTypeKey]: import_zod11.z.literal(ResponsiveColorPropControllerDataV1Type),
+var responsiveColorPropControllerDataV1Schema = import_zod13.z.object({
+  [ControlDataTypeKey]: import_zod13.z.literal(ResponsiveColorPropControllerDataV1Type),
   value: responsiveColorDataSchema
 });
-var responsiveColorPropControllerDataSchema = import_zod11.z.union([
+var responsiveColorPropControllerDataSchema = import_zod13.z.union([
   responsiveColorPropControllerDataV0Schema,
   responsiveColorPropControllerDataV1Schema
 ]);
@@ -694,13 +778,13 @@ function ResponsiveColor(options = {}) {
   return { type: Types.ResponsiveColor, version: 1, options };
 }
 function getResponsiveColorPropControllerDataResponsiveColorData(data) {
-  return (0, import_ts_pattern9.match)(data).with(
+  return (0, import_ts_pattern11.match)(data).with(
     { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createResponsiveColorPropControllerDataFromResponsiveColorData(definition, responsiveColorData) {
-  return (0, import_ts_pattern9.match)(definition).with(
+  return (0, import_ts_pattern11.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
@@ -731,7 +815,7 @@ function copyResponsiveColorData(data, context) {
   }
 }
 function copyResponsiveColorPropControllerData(data, context) {
-  return (0, import_ts_pattern9.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern11.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
@@ -741,7 +825,7 @@ function copyResponsiveColorPropControllerData(data, context) {
 }
 
 // src/navigation-links/navigation-links.ts
-var buttonVariantSchema = import_zod12.z.enum([
+var buttonVariantSchema = import_zod14.z.enum([
   "flat",
   "outline",
   "shadow",
@@ -750,13 +834,13 @@ var buttonVariantSchema = import_zod12.z.enum([
   "bubbly",
   "skewed"
 ]);
-var buttonShapeSchema = import_zod12.z.enum(["pill", "rounded", "square"]);
-var buttonSizeSchema = import_zod12.z.enum(["small", "medium", "large"]);
-var navigationButtonSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  type: import_zod12.z.literal("button"),
-  payload: import_zod12.z.object({
-    label: import_zod12.z.string(),
+var buttonShapeSchema = import_zod14.z.enum(["pill", "rounded", "square"]);
+var buttonSizeSchema = import_zod14.z.enum(["small", "medium", "large"]);
+var navigationButtonSchema = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  type: import_zod14.z.literal("button"),
+  payload: import_zod14.z.object({
+    label: import_zod14.z.string(),
     link: linkDataSchema.optional(),
     variant: createResponsiveValueSchema(buttonVariantSchema).optional(),
     shape: createResponsiveValueSchema(buttonShapeSchema).optional(),
@@ -766,28 +850,28 @@ var navigationButtonSchema = import_zod12.z.object({
     textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
   })
 });
-var navigationDropdownCaretTypeSchema = import_zod12.z.union([
-  import_zod12.z.literal("caret"),
-  import_zod12.z.literal("plus"),
-  import_zod12.z.literal("arrow-down"),
-  import_zod12.z.literal("chevron-down")
+var navigationDropdownCaretTypeSchema = import_zod14.z.union([
+  import_zod14.z.literal("caret"),
+  import_zod14.z.literal("plus"),
+  import_zod14.z.literal("arrow-down"),
+  import_zod14.z.literal("chevron-down")
 ]);
-var navigationDropdownLinkSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  payload: import_zod12.z.object({
-    label: import_zod12.z.string(),
+var navigationDropdownLinkSchema = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  payload: import_zod14.z.object({
+    label: import_zod14.z.string(),
     link: linkDataSchema.optional(),
     color: createResponsiveValueSchema(colorDataSchema).optional(),
     textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
   })
 });
-var navigationDropdownSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  type: import_zod12.z.literal("dropdown"),
-  payload: import_zod12.z.object({
-    label: import_zod12.z.string(),
+var navigationDropdownSchema = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  type: import_zod14.z.literal("dropdown"),
+  payload: import_zod14.z.object({
+    label: import_zod14.z.string(),
     caret: navigationDropdownCaretTypeSchema.optional(),
-    links: import_zod12.z.array(navigationDropdownLinkSchema).optional(),
+    links: import_zod14.z.array(navigationDropdownLinkSchema).optional(),
     variant: createResponsiveValueSchema(buttonVariantSchema).optional(),
     shape: createResponsiveValueSchema(buttonShapeSchema).optional(),
     size: createResponsiveValueSchema(buttonSizeSchema).optional(),
@@ -796,16 +880,16 @@ var navigationDropdownSchema = import_zod12.z.object({
     textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
   })
 });
-var navigationLinksDataSchema = import_zod12.z.array(
-  import_zod12.z.union([navigationButtonSchema, navigationDropdownSchema])
+var navigationLinksDataSchema = import_zod14.z.array(
+  import_zod14.z.union([navigationButtonSchema, navigationDropdownSchema])
 );
 var navigationLinksPropControllerDataV0Schema = navigationLinksDataSchema;
 var NavigationLinksPropControllerDataV1Type = "prop-controllers::navigation-links::v1";
-var navigationLinksPropControllerDataV1Schema = import_zod12.z.object({
-  [ControlDataTypeKey]: import_zod12.z.literal(NavigationLinksPropControllerDataV1Type),
+var navigationLinksPropControllerDataV1Schema = import_zod14.z.object({
+  [ControlDataTypeKey]: import_zod14.z.literal(NavigationLinksPropControllerDataV1Type),
   value: navigationLinksDataSchema
 });
-var navigationLinksPropControllerDataSchema = import_zod12.z.union([
+var navigationLinksPropControllerDataSchema = import_zod14.z.union([
   navigationLinksPropControllerDataV0Schema,
   navigationLinksPropControllerDataV1Schema
 ]);
@@ -813,13 +897,13 @@ function NavigationLinks(options = {}) {
   return { type: Types.NavigationLinks, version: 1, options };
 }
 function getNavigationLinksPropControllerDataNavigationLinksData(data) {
-  return (0, import_ts_pattern10.match)(data).with(
+  return (0, import_ts_pattern12.match)(data).with(
     { [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createNavigationLinksPropControllerDataFromNavigationLinksData(navigationLinksData, definition) {
-  return (0, import_ts_pattern10.match)(definition).with(
+  return (0, import_ts_pattern12.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type,
@@ -910,7 +994,7 @@ function copyNavigationLinksData(data, context) {
   });
 }
 function copyNavigationLinksPropControllerData(data, context) {
-  return (0, import_ts_pattern10.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern12.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type,
@@ -920,15 +1004,15 @@ function copyNavigationLinksPropControllerData(data, context) {
 }
 
 // src/number.ts
-var import_zod13 = require("zod");
-var import_ts_pattern11 = require("ts-pattern");
-var numberPropControllerDataV0Schema = import_zod13.z.number();
+var import_zod15 = require("zod");
+var import_ts_pattern13 = require("ts-pattern");
+var numberPropControllerDataV0Schema = import_zod15.z.number();
 var NumberPropControllerDataV1Type = "prop-controllers::number::v1";
-var numberPropControllerDataV1Schema = import_zod13.z.object({
-  [ControlDataTypeKey]: import_zod13.z.literal(NumberPropControllerDataV1Type),
-  value: import_zod13.z.number()
+var numberPropControllerDataV1Schema = import_zod15.z.object({
+  [ControlDataTypeKey]: import_zod15.z.literal(NumberPropControllerDataV1Type),
+  value: import_zod15.z.number()
 });
-var numberPropControllerDataSchema = import_zod13.z.union([
+var numberPropControllerDataSchema = import_zod15.z.union([
   numberPropControllerDataV0Schema,
   numberPropControllerDataV1Schema
 ]);
@@ -936,15 +1020,15 @@ function Number(options = {}) {
   return { type: Types.Number, version: 1, options };
 }
 function getNumberPropControllerDataNumber(data) {
-  return (0, import_ts_pattern11.match)(data).with(
+  return (0, import_ts_pattern13.match)(data).with(
     { [ControlDataTypeKey]: NumberPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createNumberPropControllerDataFromNumber(value, definition) {
-  return (0, import_ts_pattern11.match)(definition).with(
+  return (0, import_ts_pattern13.match)(definition).with(
     { version: 1 },
-    import_ts_pattern11.P.nullish,
+    import_ts_pattern13.P.nullish,
     () => ({
       [ControlDataTypeKey]: NumberPropControllerDataV1Type,
       value
@@ -953,13 +1037,13 @@ function createNumberPropControllerDataFromNumber(value, definition) {
 }
 
 // src/padding/padding.ts
-var import_ts_pattern12 = require("ts-pattern");
-var import_zod14 = require("zod");
-var paddingSideDataSchema = import_zod14.z.object({
-  value: import_zod14.z.number(),
-  unit: import_zod14.z.literal("px")
+var import_ts_pattern14 = require("ts-pattern");
+var import_zod16 = require("zod");
+var paddingSideDataSchema = import_zod16.z.object({
+  value: import_zod16.z.number(),
+  unit: import_zod16.z.literal("px")
 });
-var paddingDataSchema = import_zod14.z.object({
+var paddingDataSchema = import_zod16.z.object({
   paddingTop: paddingSideDataSchema.nullable().optional(),
   paddingRight: paddingSideDataSchema.nullable().optional(),
   paddingBottom: paddingSideDataSchema.nullable().optional(),
@@ -973,11 +1057,11 @@ var paddingDataSchema = import_zod14.z.object({
 var responsivePaddingDataSchema = createResponsiveValueSchema(paddingDataSchema);
 var paddingPropControllerDataV0Schema = responsivePaddingDataSchema;
 var PaddingPropControllerDataV1Type = "prop-controllers::padding::v1";
-var paddingPropControllerDataV1Schema = import_zod14.z.object({
-  [ControlDataTypeKey]: import_zod14.z.literal(PaddingPropControllerDataV1Type),
+var paddingPropControllerDataV1Schema = import_zod16.z.object({
+  [ControlDataTypeKey]: import_zod16.z.literal(PaddingPropControllerDataV1Type),
   value: responsivePaddingDataSchema
 });
-var paddingPropControllerDataSchema = import_zod14.z.union([
+var paddingPropControllerDataSchema = import_zod16.z.union([
   paddingPropControllerDataV0Schema,
   paddingPropControllerDataV1Schema
 ]);
@@ -990,15 +1074,15 @@ function Padding(options = {}) {
 }
 Padding.Format = PaddingPropControllerFormat;
 function getPaddingPropControllerDataResponsivePaddingData(data) {
-  return (0, import_ts_pattern12.match)(data).with(
+  return (0, import_ts_pattern14.match)(data).with(
     { [ControlDataTypeKey]: PaddingPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createPaddingPropControllerDataFromResponsivePaddingData(responsivePaddingData, definition) {
-  return (0, import_ts_pattern12.match)(definition).with(
+  return (0, import_ts_pattern14.match)(definition).with(
     { version: 1 },
-    import_ts_pattern12.P.nullish,
+    import_ts_pattern14.P.nullish,
     () => ({
       [ControlDataTypeKey]: PaddingPropControllerDataV1Type,
       value: responsivePaddingData
@@ -1007,16 +1091,16 @@ function createPaddingPropControllerDataFromResponsivePaddingData(responsivePadd
 }
 
 // src/responsive-length.ts
-var import_zod15 = require("zod");
-var import_ts_pattern13 = require("ts-pattern");
+var import_zod17 = require("zod");
+var import_ts_pattern15 = require("ts-pattern");
 var responsiveLengthDataSchema = createResponsiveValueSchema(lengthDataSchema);
 var responsiveLengthPropControllerDataV0Schema = responsiveLengthDataSchema;
 var ResponsiveLengthPropControllerDataV1Type = "prop-controllers::responsive-length::v1";
-var responsiveLengthPropControllerDataV1Schema = import_zod15.z.object({
-  [ControlDataTypeKey]: import_zod15.z.literal(ResponsiveLengthPropControllerDataV1Type),
+var responsiveLengthPropControllerDataV1Schema = import_zod17.z.object({
+  [ControlDataTypeKey]: import_zod17.z.literal(ResponsiveLengthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var responsiveLengthPropControllerDataSchema = import_zod15.z.union([
+var responsiveLengthPropControllerDataSchema = import_zod17.z.union([
   responsiveLengthPropControllerDataV0Schema,
   responsiveLengthPropControllerDataV1Schema
 ]);
@@ -1024,13 +1108,13 @@ function ResponsiveLength(options = {}) {
   return { type: Types.ResponsiveLength, version: 1, options };
 }
 function getResponsiveLengthPropControllerDataResponsiveLengthData(data) {
-  return (0, import_ts_pattern13.match)(data).with(
+  return (0, import_ts_pattern15.match)(data).with(
     { [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createResponsiveLengthPropControllerDataFromResponsiveLengthData(definition, responsiveLengthData) {
-  return (0, import_ts_pattern13.match)(definition).with(
+  return (0, import_ts_pattern15.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type,
@@ -1040,30 +1124,30 @@ function createResponsiveLengthPropControllerDataFromResponsiveLengthData(defini
 }
 
 // src/shadows.ts
-var import_ts_pattern14 = require("ts-pattern");
-var import_zod16 = require("zod");
-var shadowDataSchema = import_zod16.z.object({
+var import_ts_pattern16 = require("ts-pattern");
+var import_zod18 = require("zod");
+var shadowDataSchema = import_zod18.z.object({
   color: colorDataSchema.nullable().optional(),
-  blurRadius: import_zod16.z.number().optional(),
-  spreadRadius: import_zod16.z.number().optional(),
-  offsetX: import_zod16.z.number().optional(),
-  offsetY: import_zod16.z.number().optional(),
-  inset: import_zod16.z.boolean().optional()
+  blurRadius: import_zod18.z.number().optional(),
+  spreadRadius: import_zod18.z.number().optional(),
+  offsetX: import_zod18.z.number().optional(),
+  offsetY: import_zod18.z.number().optional(),
+  inset: import_zod18.z.boolean().optional()
 });
-var shadowsDataSchema = import_zod16.z.array(
-  import_zod16.z.object({
-    id: import_zod16.z.string(),
+var shadowsDataSchema = import_zod18.z.array(
+  import_zod18.z.object({
+    id: import_zod18.z.string(),
     payload: shadowDataSchema
   })
 );
 var responsiveShadowsDataSchema = createResponsiveValueSchema(shadowsDataSchema);
 var shadowsPropControllerDataV0Schema = responsiveShadowsDataSchema;
 var ShadowsPropControllerDataV1Type = "prop-controllers::shadows::v1";
-var shadowsPropControllerDataV1Schema = import_zod16.z.object({
-  [ControlDataTypeKey]: import_zod16.z.literal(ShadowsPropControllerDataV1Type),
+var shadowsPropControllerDataV1Schema = import_zod18.z.object({
+  [ControlDataTypeKey]: import_zod18.z.literal(ShadowsPropControllerDataV1Type),
   value: responsiveShadowsDataSchema
 });
-var shadowsPropControllerDataSchema = import_zod16.z.union([
+var shadowsPropControllerDataSchema = import_zod18.z.union([
   shadowsPropControllerDataV0Schema,
   shadowsPropControllerDataV1Schema
 ]);
@@ -1076,13 +1160,13 @@ function Shadows(options = {}) {
 }
 Shadows.Format = ShadowsPropControllerFormat;
 function getShadowsPropControllerDataResponsiveShadowsData(data) {
-  return (0, import_ts_pattern14.match)(data).with(
+  return (0, import_ts_pattern16.match)(data).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createShadowsPropControllerDataFromResponsiveShadowsData(definition, responsiveShadowsData) {
-  return (0, import_ts_pattern14.match)(definition).with(
+  return (0, import_ts_pattern16.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -1116,7 +1200,7 @@ function copyResponsiveShadowsData(data, context) {
   }));
 }
 function copyShadowsPropControllerData(data, context) {
-  return (0, import_ts_pattern14.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern16.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -1126,16 +1210,16 @@ function copyShadowsPropControllerData(data, context) {
 }
 
 // src/table/table.ts
-var import_zod17 = require("zod");
-var import_ts_pattern15 = require("ts-pattern");
-var tableIdSchema = import_zod17.z.string();
+var import_zod19 = require("zod");
+var import_ts_pattern17 = require("ts-pattern");
+var tableIdSchema = import_zod19.z.string();
 var tablePropControllerDataV0Schema = tableIdSchema;
 var TablePropControllerDataV1Type = "prop-controllers::table::v1";
-var tablePropControllerDataV1Schema = import_zod17.z.object({
-  [ControlDataTypeKey]: import_zod17.z.literal(TablePropControllerDataV1Type),
+var tablePropControllerDataV1Schema = import_zod19.z.object({
+  [ControlDataTypeKey]: import_zod19.z.literal(TablePropControllerDataV1Type),
   value: tableIdSchema
 });
-var tablePropControllerDataSchema = import_zod17.z.union([
+var tablePropControllerDataSchema = import_zod19.z.union([
   tablePropControllerDataV0Schema,
   tablePropControllerDataV1Schema
 ]);
@@ -1143,15 +1227,15 @@ function Table(options = {}) {
   return { type: Types.Table, version: 1, options };
 }
 function getTablePropControllerDataTableId(data) {
-  return (0, import_ts_pattern15.match)(data).with(
+  return (0, import_ts_pattern17.match)(data).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTablePropControllerDataFromTableId(value, definition) {
-  return (0, import_ts_pattern15.match)(definition).with(
+  return (0, import_ts_pattern17.match)(definition).with(
     { version: 1 },
-    import_ts_pattern15.P.nullish,
+    import_ts_pattern17.P.nullish,
     () => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
       value
@@ -1164,7 +1248,7 @@ function copyTableId(data, context) {
   return context.replacementContext.tableIds.get(data) ?? data;
 }
 function copyTablePropControllerData(data, context) {
-  return (0, import_ts_pattern15.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern17.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
@@ -1177,16 +1261,48 @@ function getTablePropControllerDataTableIds(data) {
   return value ? [value] : [];
 }
 
+// src/text-area/text-area.ts
+var import_zod20 = require("zod");
+var import_ts_pattern18 = require("ts-pattern");
+var textAreaPropControllerDataV0Schema = import_zod20.z.string();
+var TextAreaPropControllerDataV1Type = "prop-controllers::text-area::v1";
+var textAreaPropControllerDataV1Schema = import_zod20.z.object({
+  [ControlDataTypeKey]: import_zod20.z.literal(TextAreaPropControllerDataV1Type),
+  value: import_zod20.z.string()
+});
+var textAreaPropControllerDataSchema = import_zod20.z.union([
+  textAreaPropControllerDataV0Schema,
+  textAreaPropControllerDataV1Schema
+]);
+function TextArea(options = {}) {
+  return { type: Types.TextArea, version: 1, options };
+}
+function getTextAreaPropControllerDataString(data) {
+  return (0, import_ts_pattern18.match)(data).with(
+    { [ControlDataTypeKey]: TextAreaPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createTextAreaPropControllerDataFromString(value, definition) {
+  return (0, import_ts_pattern18.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: TextAreaPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
 // src/width/width.ts
-var import_ts_pattern16 = require("ts-pattern");
-var import_zod18 = require("zod");
+var import_ts_pattern19 = require("ts-pattern");
+var import_zod21 = require("zod");
 var widthPropControllerDataV0Schema = responsiveLengthDataSchema;
 var WidthPropControllerDataV1Type = "prop-controllers::width::v1";
-var widthPropControllerDataV1Schema = import_zod18.z.object({
-  [ControlDataTypeKey]: import_zod18.z.literal(WidthPropControllerDataV1Type),
+var widthPropControllerDataV1Schema = import_zod21.z.object({
+  [ControlDataTypeKey]: import_zod21.z.literal(WidthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var widthPropControllerDataSchema = import_zod18.z.union([
+var widthPropControllerDataSchema = import_zod21.z.union([
   widthPropControllerDataV0Schema,
   widthPropControllerDataV1Schema
 ]);
@@ -1199,15 +1315,15 @@ function Width(options = {}) {
 }
 Width.Format = WidthPropControllerFormat;
 function getWidthPropControllerDataResponsiveLengthData(data) {
-  return (0, import_ts_pattern16.match)(data).with(
+  return (0, import_ts_pattern19.match)(data).with(
     { [ControlDataTypeKey]: WidthPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthData, definition) {
-  return (0, import_ts_pattern16.match)(definition).with(
+  return (0, import_ts_pattern19.match)(definition).with(
     { version: 1 },
-    import_ts_pattern16.P.nullish,
+    import_ts_pattern19.P.nullish,
     () => ({
       [ControlDataTypeKey]: WidthPropControllerDataV1Type,
       value: responsiveLengthData
@@ -1216,22 +1332,22 @@ function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthD
 }
 
 // src/video/video.ts
-var import_zod19 = require("zod");
-var import_ts_pattern17 = require("ts-pattern");
-var videoDataSchema = import_zod19.z.object({
-  url: import_zod19.z.string().optional(),
-  muted: import_zod19.z.boolean().optional(),
-  playing: import_zod19.z.boolean().optional(),
-  loop: import_zod19.z.boolean().optional(),
-  controls: import_zod19.z.boolean().optional()
+var import_zod22 = require("zod");
+var import_ts_pattern20 = require("ts-pattern");
+var videoDataSchema = import_zod22.z.object({
+  url: import_zod22.z.string().optional(),
+  muted: import_zod22.z.boolean().optional(),
+  playing: import_zod22.z.boolean().optional(),
+  loop: import_zod22.z.boolean().optional(),
+  controls: import_zod22.z.boolean().optional()
 });
 var videoPropControllerDataV0Schema = videoDataSchema;
 var VideoPropControllerDataV1Type = "prop-controllers::video::v1";
-var videoPropControllerDataV1Schema = import_zod19.z.object({
-  [ControlDataTypeKey]: import_zod19.z.literal(VideoPropControllerDataV1Type),
+var videoPropControllerDataV1Schema = import_zod22.z.object({
+  [ControlDataTypeKey]: import_zod22.z.literal(VideoPropControllerDataV1Type),
   value: videoDataSchema
 });
-var videoPropControllerDataSchema = import_zod19.z.union([
+var videoPropControllerDataSchema = import_zod22.z.union([
   videoPropControllerDataV1Schema,
   videoPropControllerDataV0Schema
 ]);
@@ -1239,15 +1355,15 @@ function Video(options = {}) {
   return { type: Types.Video, version: 1, options };
 }
 function getVideoPropControllerDataVideoData(data) {
-  return (0, import_ts_pattern17.match)(data).with(
+  return (0, import_ts_pattern20.match)(data).with(
     { [ControlDataTypeKey]: VideoPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createVideoPropControllerDataFromVideoData(value, definition) {
-  return (0, import_ts_pattern17.match)(definition).with(
+  return (0, import_ts_pattern20.match)(definition).with(
     { version: 1 },
-    import_ts_pattern17.P.nullish,
+    import_ts_pattern20.P.nullish,
     () => ({
       [ControlDataTypeKey]: VideoPropControllerDataV1Type,
       value
@@ -1264,6 +1380,8 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   ControlDataTypeKey,
   Date,
   Font,
+  GapX,
+  GapY,
   Link,
   Margin,
   MarginPropControllerFormat,
@@ -1276,6 +1394,7 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   ResponsiveLengthPropControllerDataV1Type,
   Shadows,
   Table,
+  TextArea,
   TextStyle,
   Types,
   Video,
@@ -1295,6 +1414,8 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   createCheckboxPropControllerDataFromBoolean,
   createDatePropControllerDataFromString,
   createFontPropControllerDataFromResponsiveFontData,
+  createGapXPropControllerDataFromResponsiveGapData,
+  createGapYPropControllerDataFromResponsiveGapData,
   createLinkPropControllerDataFromLinkData,
   createMarginPropControllerDataFromResponsiveMarginData,
   createNavigationLinksPropControllerDataFromNavigationLinksData,
@@ -1305,17 +1426,22 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   createResponsiveValueSchema,
   createShadowsPropControllerDataFromResponsiveShadowsData,
   createTablePropControllerDataFromTableId,
+  createTextAreaPropControllerDataFromString,
   createTextStylePropControllerDataFromResponsiveTextStyleData,
   createVideoPropControllerDataFromVideoData,
   createWidthPropControllerDataFromResponsiveLengthData,
   datePropControllerDataSchema,
   fontPropControllerDataSchema,
+  gapXPropControllerDataSchema,
+  gapYPropControllerDataSchema,
   getBorderPropControllerDataResponsiveBorderData,
   getBorderPropControllerDataSwatchIds,
   getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
   getCheckboxPropControllerDataBoolean,
   getDatePropControllerDataString,
   getFontPropControllerDataResponsiveFontData,
+  getGapXPropControllerDataResponsiveGapData,
+  getGapYPropControllerDataResponsiveGapData,
   getLinkPropControllerDataLinkData,
   getLinkPropControllerPageIds,
   getMarginPropControllerDataResponsiveMarginData,
@@ -1332,6 +1458,7 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   getShadowsPropControllerDataSwatchIds,
   getTablePropControllerDataTableId,
   getTablePropControllerDataTableIds,
+  getTextAreaPropControllerDataString,
   getTextStylePropControllerDataResponsiveTextStyleData,
   getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData,
@@ -1345,6 +1472,7 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   responsiveLengthPropControllerDataSchema,
   shadowsPropControllerDataSchema,
   tablePropControllerDataSchema,
+  textAreaPropControllerDataSchema,
   textStylePropControllerDataSchema,
   videoPropControllerDataSchema,
   widthPropControllerDataSchema