@wix/auto_sdk_form-templates_form-templates 1.0.0

package/build/internal/es/schemas.mjs

@@ -0,0 +1,3160 @@
+// src/forms-v2-form-template-form-templates.schemas.ts
+import * as z from "zod";
+var ListFormTemplatesRequest = z.object({
+  namespace: z.string().describe(
+    "Namespace whose templates to retrieve. A namespace groups the templates and forms that belong to\nthe same app or use case, such as a bookings or pricing plans checkout. The value is defined by\nthe app that owns the templates in the app dashboard."
+  ).min(10).max(50),
+  options: z.object({ templateIds: z.array(z.string()).max(100).optional() }).optional()
+});
+var ListFormTemplatesResponse = z.object({
+  templates: z.array(
+    z.object({
+      _id: z.string().describe("Form template ID.").regex(
+        /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+        "Must be a valid GUID"
+      ).optional().nullable(),
+      namespace: z.string().describe(
+        "Namespace that groups this template with the templates and forms belonging to the same app or use\ncase, such as a bookings or pricing plans checkout. The value is defined by the app that owns the\ntemplate in the app dashboard, and is the value you pass when retrieving form templates."
+      ).min(10).max(50).optional(),
+      formFields: z.array(
+        z.intersection(
+          z.object({
+            _id: z.string().describe("Field ID.").regex(
+              /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+              "Must be a valid GUID"
+            ).optional(),
+            hidden: z.boolean().describe(
+              "Whether the field is hidden from submitters.\n\nDefault: `false`"
+            ).optional(),
+            identifier: z.string().describe(
+              "Custom identification for the field. This is intended as a way for you to identify certain fields that you want to apply special behavior to in your own logic."
+            ).max(50).optional().nullable(),
+            fieldType: z.enum(["UNKNOWN_FIELD_TYPE", "INPUT", "DISPLAY"]).describe("Field type.").optional()
+          }),
+          z.xor([
+            z.object({
+              inputOptions: z.never().optional(),
+              displayOptions: z.never().optional()
+            }),
+            z.object({
+              displayOptions: z.never().optional(),
+              inputOptions: z.intersection(
+                z.object({
+                  target: z.string().describe(
+                    'Human readable identifier used to reference a field, used as the key\nunder which the field\'s value is stored in a submission. For example, `"address"`.\n\nRequired for input fields. Must be unique within the form (comparison is case-sensitive).\n\nNaming rules:\n- Must start with an ASCII letter (`a`-`z` or `A`-`Z`).\n- May contain ASCII letters, digits, and underscores (`_`). No spaces, hyphens, or non-ASCII characters.\n- Consecutive underscores (`__`) are not allowed.\n- Casing is not enforced, so `camelCase`, `snake_case`, and `PascalCase` are all valid.\n\nCan be set once.'
+                  ).min(1).max(200).optional(),
+                  pii: z.boolean().describe(
+                    "Whether this field contains Personally Identifiable Information (PII).\n\nPII fields are automatically encrypted when stored.\n\nDefault: `false`"
+                  ).optional(),
+                  required: z.boolean().describe(
+                    "Whether the field is required for form submission.\n\nDefault: `false`"
+                  ).optional(),
+                  inputType: z.enum([
+                    "UNKNOWN_INPUT_TYPE",
+                    "STRING",
+                    "NUMBER",
+                    "BOOLEAN",
+                    "ARRAY",
+                    "OBJECT",
+                    "WIX_FILE",
+                    "PAYMENT",
+                    "SCHEDULING",
+                    "ADDRESS"
+                  ]).describe(
+                    "Type of the input field that determines what kind of data it collects."
+                  ).optional(),
+                  contactMapping: z.intersection(
+                    z.object({
+                      contactField: z.enum([
+                        "FIRST_NAME",
+                        "LAST_NAME",
+                        "COMPANY",
+                        "POSITION",
+                        "EMAIL",
+                        "PHONE",
+                        "ADDRESS",
+                        "BIRTHDATE",
+                        "CUSTOM_FIELD",
+                        "SUBSCRIPTION",
+                        "VAT_ID"
+                      ]).describe(
+                        "The [Contact](https://dev.wix.com/docs/rest/crm/members-contacts/contacts/contacts/introduction) field that this form field maps to."
+                      ).optional()
+                    }),
+                    z.xor([
+                      z.object({
+                        emailInfo: z.never().optional(),
+                        phoneInfo: z.never().optional(),
+                        addressInfo: z.never().optional(),
+                        customFieldInfo: z.never().optional(),
+                        subscriptionInfo: z.never().optional()
+                      }),
+                      z.object({
+                        phoneInfo: z.never().optional(),
+                        addressInfo: z.never().optional(),
+                        customFieldInfo: z.never().optional(),
+                        subscriptionInfo: z.never().optional(),
+                        emailInfo: z.object({
+                          tag: z.enum(["UNTAGGED", "MAIN"]).describe("Email categorization tag.").optional()
+                        }).describe(
+                          "Configuration for email contact fields."
+                        )
+                      }),
+                      z.object({
+                        emailInfo: z.never().optional(),
+                        addressInfo: z.never().optional(),
+                        customFieldInfo: z.never().optional(),
+                        subscriptionInfo: z.never().optional(),
+                        phoneInfo: z.object({
+                          tag: z.enum(["UNTAGGED", "MAIN"]).describe(
+                            "Phone number categorization tag."
+                          ).optional()
+                        }).describe(
+                          "Configuration for phone contact fields."
+                        )
+                      }),
+                      z.object({
+                        emailInfo: z.never().optional(),
+                        phoneInfo: z.never().optional(),
+                        customFieldInfo: z.never().optional(),
+                        subscriptionInfo: z.never().optional(),
+                        addressInfo: z.object({
+                          tag: z.enum(["UNTAGGED", "HOME"]).describe("Address categorization tag.").optional()
+                        }).describe(
+                          "Configuration for address contact fields."
+                        )
+                      }),
+                      z.object({
+                        emailInfo: z.never().optional(),
+                        phoneInfo: z.never().optional(),
+                        addressInfo: z.never().optional(),
+                        subscriptionInfo: z.never().optional(),
+                        customFieldInfo: z.object({
+                          key: z.string().describe("Custom field key.").min(1).max(500).optional()
+                        }).describe(
+                          "Configuration for custom contact fields."
+                        )
+                      }),
+                      z.object({
+                        emailInfo: z.never().optional(),
+                        phoneInfo: z.never().optional(),
+                        addressInfo: z.never().optional(),
+                        customFieldInfo: z.never().optional(),
+                        subscriptionInfo: z.object({
+                          confirmationLevel: z.enum([
+                            "UNKNOWN_CONFIRMATION_LEVEL",
+                            "SINGLE_CONFIRMATION",
+                            "DOUBLE_CONFIRMATION"
+                          ]).describe(
+                            "Subscription consent opt-in level, either single or double confirmation.\nDefault: `SINGLE_CONFIRMATION`"
+                          ).optional(),
+                          subscriptionChannels: z.array(z.enum(["EMAIL", "SMS"])).max(2).optional()
+                        }).describe(
+                          "Configuration for subscription contact fields."
+                        )
+                      })
+                    ])
+                  ).describe(
+                    "Mapping configuration for automatically saving field values to contact properties.\n\nWhen specified, form submissions automatically create or update contacts with the field data."
+                  ).optional(),
+                  readOnly: z.boolean().describe(
+                    "Whether the field is read-only.\n\nDefault: `false`"
+                  ).optional()
+                }),
+                z.xor([
+                  z.object({
+                    stringOptions: z.never().optional(),
+                    numberOptions: z.never().optional(),
+                    booleanOptions: z.never().optional(),
+                    arrayOptions: z.never().optional(),
+                    objectOptions: z.never().optional(),
+                    wixFileOptions: z.never().optional(),
+                    paymentOptions: z.never().optional(),
+                    schedulingOptions: z.never().optional(),
+                    addressOptions: z.never().optional()
+                  }),
+                  z.object({
+                    numberOptions: z.never().optional(),
+                    booleanOptions: z.never().optional(),
+                    arrayOptions: z.never().optional(),
+                    objectOptions: z.never().optional(),
+                    wixFileOptions: z.never().optional(),
+                    paymentOptions: z.never().optional(),
+                    schedulingOptions: z.never().optional(),
+                    addressOptions: z.never().optional(),
+                    stringOptions: z.intersection(
+                      z.object({
+                        validation: z.intersection(
+                          z.object({
+                            minLength: z.number().int().describe(
+                              "Minimum required length for the string value."
+                            ).min(0).max(2e4).optional().nullable(),
+                            maxLength: z.number().int().describe(
+                              "Maximum allowed length for the string value."
+                            ).min(0).max(2e4).optional().nullable(),
+                            pattern: z.string().describe(
+                              "Regular expression pattern that the string value must match."
+                            ).max(500).optional().nullable(),
+                            format: z.enum([
+                              "UNKNOWN_FORMAT",
+                              "DATE",
+                              "TIME",
+                              "DATE_TIME",
+                              "EMAIL",
+                              "URL",
+                              "UUID",
+                              "PHONE",
+                              "URI",
+                              "HOSTNAME",
+                              "COLOR_HEX",
+                              "CURRENCY",
+                              "LANGUAGE",
+                              "DATE_OPTIONAL_TIME"
+                            ]).describe(
+                              "Expected format of the string value."
+                            ).optional(),
+                            enum: z.array(z.string()).max(500).optional(),
+                            validationMessages: z.object({
+                              pattern: z.string().describe(
+                                "Error message shown when the pattern validation fails.\n\nThis message is displayed to users when their input doesn't match the specified regex pattern."
+                              ).max(200).optional().nullable()
+                            }).describe(
+                              "Custom error messages displayed when validation fails."
+                            ).optional()
+                          }),
+                          z.xor([
+                            z.object({
+                              dateOptions: z.never().optional(),
+                              dateTimeOptions: z.never().optional(),
+                              timeOptions: z.never().optional(),
+                              dateOptionalTimeOptions: z.never().optional(),
+                              phoneOptions: z.never().optional()
+                            }),
+                            z.object({
+                              dateTimeOptions: z.never().optional(),
+                              timeOptions: z.never().optional(),
+                              dateOptionalTimeOptions: z.never().optional(),
+                              phoneOptions: z.never().optional(),
+                              dateOptions: z.object({
+                                availability: z.object({
+                                  availableDates: z.array(
+                                    z.object({
+                                      start: z.string().describe(
+                                        "The beginning of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                      ).optional(),
+                                      end: z.string().describe(
+                                        "The end of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                      ).optional()
+                                    })
+                                  ).min(0).max(5).optional(),
+                                  unavailableDates: z.array(
+                                    z.object({
+                                      start: z.string().describe(
+                                        "The beginning of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                      ).optional(),
+                                      end: z.string().describe(
+                                        "The end of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                      ).optional()
+                                    })
+                                  ).min(0).max(5).optional(),
+                                  availableDays: z.array(
+                                    z.enum([
+                                      "MONDAY",
+                                      "TUESDAY",
+                                      "WEDNESDAY",
+                                      "THURSDAY",
+                                      "FRIDAY",
+                                      "SATURDAY",
+                                      "SUNDAY"
+                                    ])
+                                  ).min(0).max(7).optional()
+                                }).describe(
+                                  "Allows to specify available and unavailable dates and days of the week.\nIf unset, all dates from minimum to maximum are available."
+                                ).optional(),
+                                minimum: z.string().describe(
+                                  'Support static constrains defined as ISO date/time format, as well as\ndynamic calculations can be performed using special keywords such as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                                ).max(50).optional().nullable(),
+                                maximum: z.string().describe(
+                                  'Support static constrains defined as ISO date/time format, as well as\ndynamic calculations can be performed using special keywords such as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                                ).max(50).optional().nullable()
+                              }).describe(
+                                "Validation rules for strings with date format."
+                              )
+                            }),
+                            z.object({
+                              dateOptions: z.never().optional(),
+                              timeOptions: z.never().optional(),
+                              dateOptionalTimeOptions: z.never().optional(),
+                              phoneOptions: z.never().optional(),
+                              dateTimeOptions: z.object({
+                                minimum: z.string().describe(
+                                  'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                ).max(50).optional().nullable(),
+                                maximum: z.string().describe(
+                                  'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                ).max(50).optional().nullable()
+                              }).describe(
+                                "Validation rules for strings with date and time format."
+                              )
+                            }),
+                            z.object({
+                              dateOptions: z.never().optional(),
+                              dateTimeOptions: z.never().optional(),
+                              dateOptionalTimeOptions: z.never().optional(),
+                              phoneOptions: z.never().optional(),
+                              timeOptions: z.object({
+                                minimum: z.string().describe(
+                                  'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                ).max(50).optional().nullable(),
+                                maximum: z.string().describe(
+                                  'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                ).max(50).optional().nullable()
+                              }).describe(
+                                "Validation rules for strings with time format."
+                              )
+                            }),
+                            z.object({
+                              dateOptions: z.never().optional(),
+                              dateTimeOptions: z.never().optional(),
+                              timeOptions: z.never().optional(),
+                              phoneOptions: z.never().optional(),
+                              dateOptionalTimeOptions: z.object({
+                                minimum: z.string().describe(
+                                  'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                ).max(50).optional().nullable(),
+                                maximum: z.string().describe(
+                                  'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                ).max(50).optional().nullable()
+                              }).describe(
+                                "Validation rules for string with date and time format, where time is optional."
+                              )
+                            }),
+                            z.object({
+                              dateOptions: z.never().optional(),
+                              dateTimeOptions: z.never().optional(),
+                              timeOptions: z.never().optional(),
+                              dateOptionalTimeOptions: z.never().optional(),
+                              phoneOptions: z.object({
+                                allowedCountryCodes: z.array(z.string()).max(250).optional()
+                              }).describe(
+                                "Validation rules for strings with phone number format."
+                              )
+                            })
+                          ])
+                        ).describe(
+                          "Validation configuration for the string input."
+                        ).optional(),
+                        componentType: z.enum([
+                          "UNKNOWN_COMPONENT_TYPE",
+                          "TEXT_INPUT",
+                          "RADIO_GROUP",
+                          "DROPDOWN",
+                          "DATE_TIME",
+                          "PHONE_INPUT",
+                          "DATE_INPUT",
+                          "TIME_INPUT",
+                          "DATE_PICKER",
+                          "SERVICES_DROPDOWN",
+                          "PASSWORD"
+                        ]).describe(
+                          "Component type of the string input field."
+                        ).optional()
+                      }),
+                      z.xor([
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          radioGroupOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.never().optional()
+                        }),
+                        z.object({
+                          radioGroupOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.never().optional(),
+                          textInputOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            placeholder: z.string().describe(
+                              "Placeholder text shown inside the field when it's empty.\nUseful for providing a hint about the expected format or content."
+                            ).max(100).optional().nullable(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            default: z.string().describe(
+                              "Default value for the field. This value is pre-populated in the field when the form loads."
+                            ).max(2e4).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe("Text input component settings.")
+                        }),
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.never().optional(),
+                          radioGroupOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            options: z.array(
+                              z.object({
+                                label: z.string().describe(
+                                  "Selectable option label."
+                                ).max(400).optional().nullable(),
+                                value: z.string().describe(
+                                  "Value stored on submission when this option is selected."
+                                ).max(2e4).optional().nullable(),
+                                default: z.boolean().describe(
+                                  "Whether this option is selected by default."
+                                ).optional(),
+                                _id: z.string().describe(
+                                  "Option ID. Can be used to connect this option with [Wix Multilingual](https://dev.wix.com/docs/api-reference/business-management/multilingual/translation/introduction) for translation."
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional()
+                              })
+                            ).max(400).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            customOption: z.object({
+                              label: z.string().describe("Custom option label.").max(350).optional().nullable(),
+                              placeholder: z.string().describe(
+                                "Custom option placeholder text."
+                              ).max(100).optional().nullable()
+                            }).describe(
+                              "Custom option which can be specified by the submitter."
+                            ).optional(),
+                            numberOfColumns: z.enum(["ONE", "TWO", "THREE", "ZERO"]).describe(
+                              "Specifies the number of columns used to display the selections within the component.\n\nDefault: `ONE`"
+                            ).optional(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe(
+                            "Radio group component settings."
+                          )
+                        }),
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          radioGroupOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.never().optional(),
+                          dropdownOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            options: z.array(
+                              z.object({
+                                label: z.string().describe(
+                                  "Selectable option label."
+                                ).max(400).optional().nullable(),
+                                value: z.string().describe(
+                                  "Value stored on submission when this option is selected."
+                                ).max(2e4).optional().nullable(),
+                                default: z.boolean().describe(
+                                  "Whether this option is selected by default."
+                                ).optional(),
+                                _id: z.string().describe(
+                                  "Option ID. Can be used to connect this option with [Wix Multilingual](https://dev.wix.com/docs/api-reference/business-management/multilingual/translation/introduction) for translation."
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional()
+                              })
+                            ).max(400).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            customOption: z.object({
+                              label: z.string().describe("Custom option label.").max(350).optional().nullable(),
+                              placeholder: z.string().describe(
+                                "Custom option placeholder text."
+                              ).max(100).optional().nullable()
+                            }).describe(
+                              "Custom option which can be specified by the submitter."
+                            ).optional(),
+                            placeholder: z.string().describe(
+                              "Placeholder text shown when no option is selected."
+                            ).max(100).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe("Dropdown component settings.")
+                        }),
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          radioGroupOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.never().optional(),
+                          dateTimeOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            showPlaceholder: z.boolean().describe(
+                              "Whether to display placeholder text in the field when it's empty.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            use24HourFormat: z.boolean().describe(
+                              "Whether to use 24-hour time format.\n\nDefault: `false`"
+                            ).optional(),
+                            default: z.string().describe(
+                              'Default value for the field. This value is pre-populated in the field when the form loads.\nSupports static constrains defined as ISO date-time format, as well as dynamic calculations using special keywords\nsuch as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                            ).max(50).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional(),
+                            showDateLabels: z.boolean().describe(
+                              "Flag identifying whether to show or hide the date labels.\nDefault: true"
+                            ).optional().nullable()
+                          }).describe(
+                            "Date and time input component settings."
+                          )
+                        }),
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          radioGroupOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.never().optional(),
+                          phoneInputOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            placeholder: z.string().describe(
+                              "Placeholder text shown inside the field when it's empty."
+                            ).max(100).optional().nullable(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            defaultCountryCode: z.string().describe(
+                              "Default country code for the phone number input. Two-letter country code in ISO-3166 alpha-2 format."
+                            ).min(1).max(5).optional().nullable(),
+                            showCountryFlag: z.boolean().describe(
+                              "Whether to display the country flag next to the country code.\n\nDefault: `false`"
+                            ).optional(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe(
+                            "Phone input component settings."
+                          )
+                        }),
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          radioGroupOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.never().optional(),
+                          dateInputOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            showPlaceholder: z.boolean().describe(
+                              "Whether to display placeholder text in the field when it's empty.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            default: z.string().describe(
+                              'Default value for the field. This value is pre-populated in the field when the form loads.\nSupports static constrains defined as ISO date format, as well as dynamic calculations using special keywords\nsuch as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                            ).max(50).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional(),
+                            showDateLabels: z.boolean().describe(
+                              "Flag identifying whether to show or hide the date labels.\nDefault: true"
+                            ).optional().nullable()
+                          }).describe("Date input component settings.")
+                        }),
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          radioGroupOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.never().optional(),
+                          timeInputOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe("Field description.").optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            showPlaceholder: z.boolean().describe(
+                              "Whether to display placeholder text in the field when it's empty.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            use24HourFormat: z.boolean().describe(
+                              "Whether to use 24-hour time format.\n\nDefault: `false`"
+                            ).optional(),
+                            default: z.string().describe(
+                              'Default value for the field. This value is pre-populated in the field when the form loads.\nSupports static constrains defined as ISO time format, as well as dynamic calculations using special keywords\nsuch as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                            ).max(50).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe("Time input component settings.")
+                        }),
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          radioGroupOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.never().optional(),
+                          datePickerOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            placeholder: z.string().describe(
+                              "Placeholder text shown when no date is selected."
+                            ).max(100).optional().nullable(),
+                            firstDayOfWeek: z.enum(["MONDAY", "SUNDAY"]).describe(
+                              "First day of the week displayed on the date picker."
+                            ).optional(),
+                            default: z.string().describe(
+                              'Default value for the field. This value is pre-populated in the field when the form loads.\nSupports static constrains defined as ISO date format, as well as dynamic calculations using special keywords\nsuch as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                            ).max(50).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe(
+                            "Date picker component settings."
+                          )
+                        }),
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          radioGroupOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          passwordOptions: z.never().optional(),
+                          servicesDropdownOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            placeholder: z.string().describe(
+                              "Placeholder text shown when no service is selected."
+                            ).max(100).optional().nullable(),
+                            options: z.array(
+                              z.object({
+                                label: z.string().describe("Service name/label").max(400).optional().nullable(),
+                                _id: z.string().describe(
+                                  "Option id. Used as binding for translations. Corresponds to the Service ID."
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional(),
+                                value: z.string().describe(
+                                  "Selectable option value, which is saved to DB. Corresponds to the Service ID."
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional().nullable()
+                              })
+                            ).max(400).optional(),
+                            customOption: z.object({
+                              label: z.string().describe("Custom option label.").max(350).optional().nullable(),
+                              placeholder: z.string().describe(
+                                "Custom option placeholder text."
+                              ).max(100).optional().nullable()
+                            }).describe(
+                              "Custom option which can be specified by the submitter."
+                            ).optional(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional()
+                          }).describe(
+                            "Services dropdown component settings."
+                          )
+                        }),
+                        z.object({
+                          textInputOptions: z.never().optional(),
+                          radioGroupOptions: z.never().optional(),
+                          dropdownOptions: z.never().optional(),
+                          dateTimeOptions: z.never().optional(),
+                          phoneInputOptions: z.never().optional(),
+                          dateInputOptions: z.never().optional(),
+                          timeInputOptions: z.never().optional(),
+                          datePickerOptions: z.never().optional(),
+                          servicesDropdownOptions: z.never().optional(),
+                          passwordOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            placeholder: z.string().describe(
+                              "Placeholder text shown inside the field when it's empty.\nUseful for providing a hint about the expected format or content."
+                            ).max(100).optional().nullable(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            default: z.string().describe(
+                              "Default value for the field. This value is pre-populated in the field when the form loads."
+                            ).max(2e4).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe("Password component settings.")
+                        })
+                      ])
+                    ).describe("String input field settings.")
+                  }),
+                  z.object({
+                    stringOptions: z.never().optional(),
+                    booleanOptions: z.never().optional(),
+                    arrayOptions: z.never().optional(),
+                    objectOptions: z.never().optional(),
+                    wixFileOptions: z.never().optional(),
+                    paymentOptions: z.never().optional(),
+                    schedulingOptions: z.never().optional(),
+                    addressOptions: z.never().optional(),
+                    numberOptions: z.intersection(
+                      z.object({
+                        validation: z.object({
+                          maximum: z.number().describe(
+                            "The maximum value of the number. Inclusive."
+                          ).optional().nullable(),
+                          minimum: z.number().describe(
+                            "The minimum value of the number. Inclusive."
+                          ).optional().nullable(),
+                          multipleOf: z.number().describe(
+                            "A number that the value must be a multiple of."
+                          ).optional().nullable(),
+                          enum: z.array(z.number()).max(500).optional()
+                        }).describe(
+                          "Validation configuration for the number input."
+                        ).optional(),
+                        componentType: z.enum([
+                          "UNKNOWN_COMPONENT_TYPE",
+                          "NUMBER_INPUT",
+                          "RATING_INPUT"
+                        ]).describe(
+                          "Component type of the number input field."
+                        ).optional()
+                      }),
+                      z.xor([
+                        z.object({
+                          numberInputOptions: z.never().optional(),
+                          ratingInputOptions: z.never().optional()
+                        }),
+                        z.object({
+                          ratingInputOptions: z.never().optional(),
+                          numberInputOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            placeholder: z.string().describe(
+                              "Placeholder text shown inside the field when it's empty."
+                            ).max(100).optional().nullable(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            default: z.number().describe(
+                              "Default value for the field. This value is pre-populated in the field when the form loads."
+                            ).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe("Number input settings.")
+                        }),
+                        z.object({
+                          numberInputOptions: z.never().optional(),
+                          ratingInputOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            defaultValue: z.number().int().describe(
+                              "Default rating value for the field."
+                            ).min(1).max(5).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe("Rating input settings.")
+                        })
+                      ])
+                    ).describe("Number input field settings.")
+                  }),
+                  z.object({
+                    stringOptions: z.never().optional(),
+                    numberOptions: z.never().optional(),
+                    arrayOptions: z.never().optional(),
+                    objectOptions: z.never().optional(),
+                    wixFileOptions: z.never().optional(),
+                    paymentOptions: z.never().optional(),
+                    schedulingOptions: z.never().optional(),
+                    addressOptions: z.never().optional(),
+                    booleanOptions: z.intersection(
+                      z.object({
+                        validation: z.object({
+                          enum: z.array(z.boolean()).max(2).optional()
+                        }).describe(
+                          "Validation configuration for the boolean input."
+                        ).optional(),
+                        componentType: z.enum(["UNKNOWN_COMPONENT_TYPE", "CHECKBOX"]).describe(
+                          "Component type of the boolean input field."
+                        ).optional()
+                      }),
+                      z.xor([
+                        z.object({
+                          checkboxOptions: z.never().optional()
+                        }),
+                        z.object({
+                          checkboxOptions: z.object({
+                            label: z.any().describe("Field label.").optional(),
+                            checked: z.boolean().describe(
+                              "Whether the checkbox is selected by default when the form loads.\n\nDefault: `false`"
+                            ).optional()
+                          }).describe("Checkbox component settings.")
+                        })
+                      ])
+                    ).describe("Boolean input field settings.")
+                  }),
+                  z.object({
+                    stringOptions: z.never().optional(),
+                    numberOptions: z.never().optional(),
+                    booleanOptions: z.never().optional(),
+                    objectOptions: z.never().optional(),
+                    wixFileOptions: z.never().optional(),
+                    paymentOptions: z.never().optional(),
+                    schedulingOptions: z.never().optional(),
+                    addressOptions: z.never().optional(),
+                    arrayOptions: z.intersection(
+                      z.object({
+                        validation: z.object({
+                          maxItems: z.number().int().describe(
+                            "Maximum number of elements allowed in the array."
+                          ).min(0).max(1e3).optional().nullable(),
+                          minItems: z.number().int().describe(
+                            "Minimum number of elements required in the array."
+                          ).min(0).max(1e3).optional().nullable(),
+                          items: z.intersection(
+                            z.object({
+                              itemType: z.enum([
+                                "STRING",
+                                "NUMBER",
+                                "BOOLEAN"
+                              ]).describe("Allowed item type.").optional()
+                            }),
+                            z.xor([
+                              z.object({
+                                stringOptions: z.never().optional(),
+                                numberOptions: z.never().optional(),
+                                booleanOptions: z.never().optional()
+                              }),
+                              z.object({
+                                numberOptions: z.never().optional(),
+                                booleanOptions: z.never().optional(),
+                                stringOptions: z.intersection(
+                                  z.object({
+                                    minLength: z.number().int().describe(
+                                      "Minimum required length for the string value."
+                                    ).min(0).max(2e4).optional().nullable(),
+                                    maxLength: z.number().int().describe(
+                                      "Maximum allowed length for the string value."
+                                    ).min(0).max(2e4).optional().nullable(),
+                                    pattern: z.string().describe(
+                                      "Regular expression pattern that the string value must match."
+                                    ).max(500).optional().nullable(),
+                                    format: z.enum([
+                                      "UNKNOWN_FORMAT",
+                                      "DATE",
+                                      "TIME",
+                                      "DATE_TIME",
+                                      "EMAIL",
+                                      "URL",
+                                      "UUID",
+                                      "PHONE",
+                                      "URI",
+                                      "HOSTNAME",
+                                      "COLOR_HEX",
+                                      "CURRENCY",
+                                      "LANGUAGE",
+                                      "DATE_OPTIONAL_TIME"
+                                    ]).describe(
+                                      "Expected format of the string value."
+                                    ).optional(),
+                                    enum: z.array(z.string()).max(500).optional(),
+                                    validationMessages: z.object({
+                                      pattern: z.string().describe(
+                                        "Error message shown when the pattern validation fails.\n\nThis message is displayed to users when their input doesn't match the specified regex pattern."
+                                      ).max(200).optional().nullable()
+                                    }).describe(
+                                      "Custom error messages displayed when validation fails."
+                                    ).optional()
+                                  }),
+                                  z.xor([
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      dateTimeOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional()
+                                    }),
+                                    z.object({
+                                      dateTimeOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional(),
+                                      dateOptions: z.object({
+                                        availability: z.object({
+                                          availableDates: z.array(
+                                            z.object({
+                                              start: z.string().describe(
+                                                "The beginning of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                              ).optional(),
+                                              end: z.string().describe(
+                                                "The end of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                              ).optional()
+                                            })
+                                          ).min(0).max(5).optional(),
+                                          unavailableDates: z.array(
+                                            z.object({
+                                              start: z.string().describe(
+                                                "The beginning of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                              ).optional(),
+                                              end: z.string().describe(
+                                                "The end of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                              ).optional()
+                                            })
+                                          ).min(0).max(5).optional(),
+                                          availableDays: z.array(
+                                            z.enum([
+                                              "MONDAY",
+                                              "TUESDAY",
+                                              "WEDNESDAY",
+                                              "THURSDAY",
+                                              "FRIDAY",
+                                              "SATURDAY",
+                                              "SUNDAY"
+                                            ])
+                                          ).min(0).max(7).optional()
+                                        }).describe(
+                                          "Allows to specify available and unavailable dates and days of the week.\nIf unset, all dates from minimum to maximum are available."
+                                        ).optional(),
+                                        minimum: z.string().describe(
+                                          'Support static constrains defined as ISO date/time format, as well as\ndynamic calculations can be performed using special keywords such as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                                        ).max(50).optional().nullable(),
+                                        maximum: z.string().describe(
+                                          'Support static constrains defined as ISO date/time format, as well as\ndynamic calculations can be performed using special keywords such as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                                        ).max(50).optional().nullable()
+                                      }).describe(
+                                        "Validation rules for strings with date format."
+                                      )
+                                    }),
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional(),
+                                      dateTimeOptions: z.object({
+                                        minimum: z.string().describe(
+                                          'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable(),
+                                        maximum: z.string().describe(
+                                          'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable()
+                                      }).describe(
+                                        "Validation rules for strings with date and time format."
+                                      )
+                                    }),
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      dateTimeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional(),
+                                      timeOptions: z.object({
+                                        minimum: z.string().describe(
+                                          'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable(),
+                                        maximum: z.string().describe(
+                                          'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable()
+                                      }).describe(
+                                        "Validation rules for strings with time format."
+                                      )
+                                    }),
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      dateTimeOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.object({
+                                        minimum: z.string().describe(
+                                          'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable(),
+                                        maximum: z.string().describe(
+                                          'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable()
+                                      }).describe(
+                                        "Validation rules for string with date and time format, where time is optional."
+                                      )
+                                    }),
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      dateTimeOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.object({
+                                        allowedCountryCodes: z.array(z.string()).max(250).optional()
+                                      }).describe(
+                                        "Validation rules for strings with phone number format."
+                                      )
+                                    })
+                                  ])
+                                ).describe(
+                                  "Validation rules for string array elements."
+                                )
+                              }),
+                              z.object({
+                                stringOptions: z.never().optional(),
+                                booleanOptions: z.never().optional(),
+                                numberOptions: z.object({
+                                  maximum: z.number().describe(
+                                    "The maximum value of the number. Inclusive."
+                                  ).optional().nullable(),
+                                  minimum: z.number().describe(
+                                    "The minimum value of the number. Inclusive."
+                                  ).optional().nullable(),
+                                  multipleOf: z.number().describe(
+                                    "A number that the value must be a multiple of."
+                                  ).optional().nullable(),
+                                  enum: z.array(z.number()).max(500).optional()
+                                }).describe(
+                                  "Validation rules for numeric array elements."
+                                )
+                              }),
+                              z.object({
+                                stringOptions: z.never().optional(),
+                                numberOptions: z.never().optional(),
+                                booleanOptions: z.object({
+                                  enum: z.array(z.boolean()).max(2).optional()
+                                }).describe(
+                                  "Validation rules for boolean array elements."
+                                )
+                              })
+                            ])
+                          ).describe(
+                            "Type of items allowed in the array."
+                          ).optional()
+                        }).describe(
+                          "Validation configuration for the array input."
+                        ).optional(),
+                        componentType: z.enum([
+                          "UNKNOWN_COMPONENT_TYPE",
+                          "CHECKBOX_GROUP",
+                          "TAGS",
+                          "SERVICES_CHECKBOX_GROUP"
+                        ]).describe(
+                          "Component type of the array input field."
+                        ).optional()
+                      }),
+                      z.xor([
+                        z.object({
+                          checkboxGroupOptions: z.never().optional(),
+                          tagsOptions: z.never().optional(),
+                          servicesCheckboxGroupOptions: z.never().optional()
+                        }),
+                        z.object({
+                          tagsOptions: z.never().optional(),
+                          servicesCheckboxGroupOptions: z.never().optional(),
+                          checkboxGroupOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            options: z.array(
+                              z.object({
+                                label: z.string().describe(
+                                  "Selectable option label."
+                                ).max(400).optional().nullable(),
+                                value: z.any().describe(
+                                  "Value stored on submission when this option is selected."
+                                ).optional().nullable(),
+                                default: z.boolean().describe(
+                                  "Whether this option is selected by default."
+                                ).optional(),
+                                _id: z.string().describe(
+                                  "Option ID. Can be used to connect this option with [Wix Multilingual](https://dev.wix.com/docs/api-reference/business-management/multilingual/translation/introduction) for translation."
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional(),
+                                media: z.intersection(
+                                  z.object({}),
+                                  z.xor([
+                                    z.object({
+                                      image: z.never().optional()
+                                    }),
+                                    z.object({
+                                      image: z.string().describe(
+                                        "WixMedia image."
+                                      )
+                                    })
+                                  ])
+                                ).describe(
+                                  "Media content associated with this option."
+                                ).optional(),
+                                showLabel: z.boolean().describe(
+                                  "Whether to display the option label.\n\nDefault: `true`"
+                                ).optional().nullable()
+                              })
+                            ).max(400).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            customOption: z.object({
+                              label: z.string().describe("Custom option label.").max(350).optional().nullable(),
+                              placeholder: z.string().describe(
+                                "Custom option placeholder text."
+                              ).max(100).optional().nullable()
+                            }).describe(
+                              "Custom option which can be specified by the submitter."
+                            ).optional(),
+                            numberOfColumns: z.enum(["ONE", "TWO", "THREE", "ZERO"]).describe(
+                              "Specifies the number of columns used to display the selections within the component.\n\nDefault: `ONE`"
+                            ).optional(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional(),
+                            optionsMediaSettings: z.object({
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Display settings for `Option.media`, applied uniformly to all options."
+                            ).optional()
+                          }).describe(
+                            "Checkbox group component settings."
+                          )
+                        }),
+                        z.object({
+                          checkboxGroupOptions: z.never().optional(),
+                          servicesCheckboxGroupOptions: z.never().optional(),
+                          tagsOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            options: z.array(
+                              z.object({
+                                label: z.string().describe(
+                                  "Selectable option label."
+                                ).max(400).optional().nullable(),
+                                value: z.any().describe(
+                                  "Value stored on submission when this option is selected."
+                                ).optional().nullable(),
+                                default: z.boolean().describe(
+                                  "Flag identifying that option should be selected by default."
+                                ).optional(),
+                                _id: z.string().describe(
+                                  "Option id. Used as binding for translations"
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional(),
+                                media: z.intersection(
+                                  z.object({}),
+                                  z.xor([
+                                    z.object({
+                                      image: z.never().optional()
+                                    }),
+                                    z.object({
+                                      image: z.string().describe(
+                                        "WixMedia image."
+                                      )
+                                    })
+                                  ])
+                                ).describe(
+                                  "Media content associated with the option, such as an image."
+                                ).optional()
+                              })
+                            ).max(400).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            customOption: z.object({
+                              label: z.string().describe("Custom option label.").max(350).optional().nullable(),
+                              placeholder: z.string().describe(
+                                "Custom option placeholder text."
+                              ).max(100).optional().nullable()
+                            }).describe(
+                              "Custom option which can be specified by the submitter."
+                            ).optional(),
+                            numberOfColumns: z.enum(["ONE", "TWO", "THREE", "ZERO"]).describe(
+                              "Specifies the number of columns used to display the selections within the component.\n\nDefault: `ONE`"
+                            ).optional(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media item. Media, associated with field, like image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media item."
+                            ).optional()
+                          }).describe("Tags component settings.")
+                        }),
+                        z.object({
+                          checkboxGroupOptions: z.never().optional(),
+                          tagsOptions: z.never().optional(),
+                          servicesCheckboxGroupOptions: z.object({
+                            label: z.string().describe("Label of the field").max(350).optional().nullable(),
+                            description: z.any().describe("Description of the field").optional(),
+                            options: z.array(
+                              z.object({
+                                label: z.string().describe("Service name/label").max(400).optional().nullable(),
+                                _id: z.string().describe(
+                                  "Option id. Used as binding for translations. Corresponds to the Service ID."
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional(),
+                                value: z.string().describe(
+                                  "Selectable option value, which is saved to DB. Corresponds to the Service ID."
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional().nullable()
+                              })
+                            ).max(100).optional(),
+                            showLabel: z.boolean().describe(
+                              "Flag identifying to hide or not label\nDefault: true"
+                            ).optional().nullable(),
+                            customOption: z.object({
+                              label: z.string().describe("Custom option label.").max(350).optional().nullable(),
+                              placeholder: z.string().describe(
+                                "Custom option placeholder text."
+                              ).max(100).optional().nullable()
+                            }).describe(
+                              "Option which can be specified by UoU, enabled when this object is specified."
+                            ).optional(),
+                            numberOfColumns: z.enum(["ONE", "TWO", "THREE", "ZERO"]).describe(
+                              "Specifies the number of columns used to display the selections within the component.\nDefault: ONE"
+                            ).optional()
+                          }).describe(
+                            "Services checkbox group input field"
+                          )
+                        })
+                      ])
+                    ).describe("Array input field settings.")
+                  }),
+                  z.object({
+                    stringOptions: z.never().optional(),
+                    numberOptions: z.never().optional(),
+                    booleanOptions: z.never().optional(),
+                    arrayOptions: z.never().optional(),
+                    wixFileOptions: z.never().optional(),
+                    paymentOptions: z.never().optional(),
+                    schedulingOptions: z.never().optional(),
+                    addressOptions: z.never().optional(),
+                    objectOptions: z.object({
+                      validation: z.object({
+                        properties: z.record(
+                          z.string(),
+                          z.intersection(
+                            z.object({
+                              propertiesType: z.enum([
+                                "STRING",
+                                "NUMBER",
+                                "BOOLEAN",
+                                "ARRAY"
+                              ]).describe(
+                                "Data type of the object property."
+                              ).optional(),
+                              required: z.boolean().describe(
+                                "Whether the object property is required for validation."
+                              ).optional()
+                            }),
+                            z.xor([
+                              z.object({
+                                stringOptions: z.never().optional(),
+                                numberOptions: z.never().optional(),
+                                booleanOptions: z.never().optional(),
+                                arrayOptions: z.never().optional()
+                              }),
+                              z.object({
+                                numberOptions: z.never().optional(),
+                                booleanOptions: z.never().optional(),
+                                arrayOptions: z.never().optional(),
+                                stringOptions: z.intersection(
+                                  z.object({
+                                    minLength: z.number().int().describe(
+                                      "Minimum required length for the string value."
+                                    ).min(0).max(2e4).optional().nullable(),
+                                    maxLength: z.number().int().describe(
+                                      "Maximum allowed length for the string value."
+                                    ).min(0).max(2e4).optional().nullable(),
+                                    pattern: z.string().describe(
+                                      "Regular expression pattern that the string value must match."
+                                    ).max(500).optional().nullable(),
+                                    format: z.enum([
+                                      "UNKNOWN_FORMAT",
+                                      "DATE",
+                                      "TIME",
+                                      "DATE_TIME",
+                                      "EMAIL",
+                                      "URL",
+                                      "UUID",
+                                      "PHONE",
+                                      "URI",
+                                      "HOSTNAME",
+                                      "COLOR_HEX",
+                                      "CURRENCY",
+                                      "LANGUAGE",
+                                      "DATE_OPTIONAL_TIME"
+                                    ]).describe(
+                                      "Expected format of the string value."
+                                    ).optional(),
+                                    enum: z.array(z.string()).max(500).optional(),
+                                    validationMessages: z.object({
+                                      pattern: z.string().describe(
+                                        "Error message shown when the pattern validation fails.\n\nThis message is displayed to users when their input doesn't match the specified regex pattern."
+                                      ).max(200).optional().nullable()
+                                    }).describe(
+                                      "Custom error messages displayed when validation fails."
+                                    ).optional()
+                                  }),
+                                  z.xor([
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      dateTimeOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional()
+                                    }),
+                                    z.object({
+                                      dateTimeOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional(),
+                                      dateOptions: z.object({
+                                        availability: z.object({
+                                          availableDates: z.array(
+                                            z.object({
+                                              start: z.string().describe(
+                                                "The beginning of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                              ).optional(),
+                                              end: z.string().describe(
+                                                "The end of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                              ).optional()
+                                            })
+                                          ).min(0).max(5).optional(),
+                                          unavailableDates: z.array(
+                                            z.object({
+                                              start: z.string().describe(
+                                                "The beginning of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                              ).optional(),
+                                              end: z.string().describe(
+                                                "The end of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                              ).optional()
+                                            })
+                                          ).min(0).max(5).optional(),
+                                          availableDays: z.array(
+                                            z.enum([
+                                              "MONDAY",
+                                              "TUESDAY",
+                                              "WEDNESDAY",
+                                              "THURSDAY",
+                                              "FRIDAY",
+                                              "SATURDAY",
+                                              "SUNDAY"
+                                            ])
+                                          ).min(0).max(7).optional()
+                                        }).describe(
+                                          "Allows to specify available and unavailable dates and days of the week.\nIf unset, all dates from minimum to maximum are available."
+                                        ).optional(),
+                                        minimum: z.string().describe(
+                                          'Support static constrains defined as ISO date/time format, as well as\ndynamic calculations can be performed using special keywords such as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                                        ).max(50).optional().nullable(),
+                                        maximum: z.string().describe(
+                                          'Support static constrains defined as ISO date/time format, as well as\ndynamic calculations can be performed using special keywords such as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                                        ).max(50).optional().nullable()
+                                      }).describe(
+                                        "Validation rules for strings with date format."
+                                      )
+                                    }),
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional(),
+                                      dateTimeOptions: z.object({
+                                        minimum: z.string().describe(
+                                          'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable(),
+                                        maximum: z.string().describe(
+                                          'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable()
+                                      }).describe(
+                                        "Validation rules for strings with date and time format."
+                                      )
+                                    }),
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      dateTimeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional(),
+                                      timeOptions: z.object({
+                                        minimum: z.string().describe(
+                                          'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable(),
+                                        maximum: z.string().describe(
+                                          'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable()
+                                      }).describe(
+                                        "Validation rules for strings with time format."
+                                      )
+                                    }),
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      dateTimeOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      phoneOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.object({
+                                        minimum: z.string().describe(
+                                          'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable(),
+                                        maximum: z.string().describe(
+                                          'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                        ).max(50).optional().nullable()
+                                      }).describe(
+                                        "Validation rules for string with date and time format, where time is optional."
+                                      )
+                                    }),
+                                    z.object({
+                                      dateOptions: z.never().optional(),
+                                      dateTimeOptions: z.never().optional(),
+                                      timeOptions: z.never().optional(),
+                                      dateOptionalTimeOptions: z.never().optional(),
+                                      phoneOptions: z.object({
+                                        allowedCountryCodes: z.array(z.string()).max(250).optional()
+                                      }).describe(
+                                        "Validation rules for strings with phone number format."
+                                      )
+                                    })
+                                  ])
+                                ).describe(
+                                  "Validation rules for string properties."
+                                )
+                              }),
+                              z.object({
+                                stringOptions: z.never().optional(),
+                                booleanOptions: z.never().optional(),
+                                arrayOptions: z.never().optional(),
+                                numberOptions: z.object({
+                                  maximum: z.number().describe(
+                                    "The maximum value of the number. Inclusive."
+                                  ).optional().nullable(),
+                                  minimum: z.number().describe(
+                                    "The minimum value of the number. Inclusive."
+                                  ).optional().nullable(),
+                                  multipleOf: z.number().describe(
+                                    "A number that the value must be a multiple of."
+                                  ).optional().nullable(),
+                                  enum: z.array(z.number()).max(500).optional()
+                                }).describe(
+                                  "Validation rules for numeric properties."
+                                )
+                              }),
+                              z.object({
+                                stringOptions: z.never().optional(),
+                                numberOptions: z.never().optional(),
+                                arrayOptions: z.never().optional(),
+                                booleanOptions: z.object({
+                                  enum: z.array(z.boolean()).max(2).optional()
+                                }).describe(
+                                  "Validation rules for boolean properties."
+                                )
+                              }),
+                              z.object({
+                                stringOptions: z.never().optional(),
+                                numberOptions: z.never().optional(),
+                                booleanOptions: z.never().optional(),
+                                arrayOptions: z.object({
+                                  maxItems: z.number().int().describe(
+                                    "Maximum number of elements allowed in the array."
+                                  ).min(0).max(1e3).optional().nullable(),
+                                  minItems: z.number().int().describe(
+                                    "Minimum number of elements required in the array."
+                                  ).min(0).max(1e3).optional().nullable(),
+                                  items: z.intersection(
+                                    z.object({
+                                      itemType: z.enum([
+                                        "STRING",
+                                        "NUMBER",
+                                        "BOOLEAN"
+                                      ]).describe(
+                                        "Allowed item type."
+                                      ).optional()
+                                    }),
+                                    z.xor([
+                                      z.object({
+                                        stringOptions: z.never().optional(),
+                                        numberOptions: z.never().optional(),
+                                        booleanOptions: z.never().optional()
+                                      }),
+                                      z.object({
+                                        numberOptions: z.never().optional(),
+                                        booleanOptions: z.never().optional(),
+                                        stringOptions: z.intersection(
+                                          z.object({
+                                            minLength: z.number().int().describe(
+                                              "Minimum required length for the string value."
+                                            ).min(0).max(2e4).optional().nullable(),
+                                            maxLength: z.number().int().describe(
+                                              "Maximum allowed length for the string value."
+                                            ).min(0).max(2e4).optional().nullable(),
+                                            pattern: z.string().describe(
+                                              "Regular expression pattern that the string value must match."
+                                            ).max(500).optional().nullable(),
+                                            format: z.enum([
+                                              "UNKNOWN_FORMAT",
+                                              "DATE",
+                                              "TIME",
+                                              "DATE_TIME",
+                                              "EMAIL",
+                                              "URL",
+                                              "UUID",
+                                              "PHONE",
+                                              "URI",
+                                              "HOSTNAME",
+                                              "COLOR_HEX",
+                                              "CURRENCY",
+                                              "LANGUAGE",
+                                              "DATE_OPTIONAL_TIME"
+                                            ]).describe(
+                                              "Expected format of the string value."
+                                            ).optional(),
+                                            enum: z.array(
+                                              z.string()
+                                            ).max(500).optional(),
+                                            validationMessages: z.object({
+                                              pattern: z.string().describe(
+                                                "Error message shown when the pattern validation fails.\n\nThis message is displayed to users when their input doesn't match the specified regex pattern."
+                                              ).max(200).optional().nullable()
+                                            }).describe(
+                                              "Custom error messages displayed when validation fails."
+                                            ).optional()
+                                          }),
+                                          z.xor([
+                                            z.object({
+                                              dateOptions: z.never().optional(),
+                                              dateTimeOptions: z.never().optional(),
+                                              timeOptions: z.never().optional(),
+                                              dateOptionalTimeOptions: z.never().optional(),
+                                              phoneOptions: z.never().optional()
+                                            }),
+                                            z.object({
+                                              dateTimeOptions: z.never().optional(),
+                                              timeOptions: z.never().optional(),
+                                              dateOptionalTimeOptions: z.never().optional(),
+                                              phoneOptions: z.never().optional(),
+                                              dateOptions: z.object({
+                                                availability: z.object(
+                                                  {
+                                                    availableDates: z.array(
+                                                      z.object(
+                                                        {
+                                                          start: z.string().describe(
+                                                            "The beginning of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                                          ).optional(),
+                                                          end: z.string().describe(
+                                                            "The end of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                                          ).optional()
+                                                        }
+                                                      )
+                                                    ).min(
+                                                      0
+                                                    ).max(
+                                                      5
+                                                    ).optional(),
+                                                    unavailableDates: z.array(
+                                                      z.object(
+                                                        {
+                                                          start: z.string().describe(
+                                                            "The beginning of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                                          ).optional(),
+                                                          end: z.string().describe(
+                                                            "The end of the date range (inclusive). ISO 8601 date format (YYYY-MM-DD)."
+                                                          ).optional()
+                                                        }
+                                                      )
+                                                    ).min(
+                                                      0
+                                                    ).max(
+                                                      5
+                                                    ).optional(),
+                                                    availableDays: z.array(
+                                                      z.enum(
+                                                        [
+                                                          "MONDAY",
+                                                          "TUESDAY",
+                                                          "WEDNESDAY",
+                                                          "THURSDAY",
+                                                          "FRIDAY",
+                                                          "SATURDAY",
+                                                          "SUNDAY"
+                                                        ]
+                                                      )
+                                                    ).min(
+                                                      0
+                                                    ).max(
+                                                      7
+                                                    ).optional()
+                                                  }
+                                                ).describe(
+                                                  "Allows to specify available and unavailable dates and days of the week.\nIf unset, all dates from minimum to maximum are available."
+                                                ).optional(),
+                                                minimum: z.string().describe(
+                                                  'Support static constrains defined as ISO date/time format, as well as\ndynamic calculations can be performed using special keywords such as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                                                ).max(50).optional().nullable(),
+                                                maximum: z.string().describe(
+                                                  'Support static constrains defined as ISO date/time format, as well as\ndynamic calculations can be performed using special keywords such as "$now" to represent the current date and time.\nThe dynamic calculation supports expressions like "$now+2d" (2 days in the future), "$now-1h" (1 hour in the past), etc.\nThe regex pattern for dynamic calculations is: \\$now([+-]\\d{1,2})([yMdmh])'
+                                                ).max(50).optional().nullable()
+                                              }).describe(
+                                                "Validation rules for strings with date format."
+                                              )
+                                            }),
+                                            z.object({
+                                              dateOptions: z.never().optional(),
+                                              timeOptions: z.never().optional(),
+                                              dateOptionalTimeOptions: z.never().optional(),
+                                              phoneOptions: z.never().optional(),
+                                              dateTimeOptions: z.object({
+                                                minimum: z.string().describe(
+                                                  'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                                ).max(50).optional().nullable(),
+                                                maximum: z.string().describe(
+                                                  'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                                ).max(50).optional().nullable()
+                                              }).describe(
+                                                "Validation rules for strings with date and time format."
+                                              )
+                                            }),
+                                            z.object({
+                                              dateOptions: z.never().optional(),
+                                              dateTimeOptions: z.never().optional(),
+                                              dateOptionalTimeOptions: z.never().optional(),
+                                              phoneOptions: z.never().optional(),
+                                              timeOptions: z.object({
+                                                minimum: z.string().describe(
+                                                  'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                                ).max(50).optional().nullable(),
+                                                maximum: z.string().describe(
+                                                  'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                                ).max(50).optional().nullable()
+                                              }).describe(
+                                                "Validation rules for strings with time format."
+                                              )
+                                            }),
+                                            z.object({
+                                              dateOptions: z.never().optional(),
+                                              dateTimeOptions: z.never().optional(),
+                                              timeOptions: z.never().optional(),
+                                              phoneOptions: z.never().optional(),
+                                              dateOptionalTimeOptions: z.object({
+                                                minimum: z.string().describe(
+                                                  'Minimum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                                ).max(50).optional().nullable(),
+                                                maximum: z.string().describe(
+                                                  'Maximum allowed datetime value.\n\nSupports ISO datetime format or dynamic calculations using "$now" keyword.\nThe dynamic calculation supports times in the future and past.\nThe pattern for dynamic calculations: $now([+-]\\d{1,2})([yMdmh]).\n\nExamples: `"2023-01-01"`, `"$now-1d"` (1 day ago), `"$now+2h"` (2 hours from now).'
+                                                ).max(50).optional().nullable()
+                                              }).describe(
+                                                "Validation rules for string with date and time format, where time is optional."
+                                              )
+                                            }),
+                                            z.object({
+                                              dateOptions: z.never().optional(),
+                                              dateTimeOptions: z.never().optional(),
+                                              timeOptions: z.never().optional(),
+                                              dateOptionalTimeOptions: z.never().optional(),
+                                              phoneOptions: z.object({
+                                                allowedCountryCodes: z.array(
+                                                  z.string()
+                                                ).max(
+                                                  250
+                                                ).optional()
+                                              }).describe(
+                                                "Validation rules for strings with phone number format."
+                                              )
+                                            })
+                                          ])
+                                        ).describe(
+                                          "Validation rules for string array elements."
+                                        )
+                                      }),
+                                      z.object({
+                                        stringOptions: z.never().optional(),
+                                        booleanOptions: z.never().optional(),
+                                        numberOptions: z.object({
+                                          maximum: z.number().describe(
+                                            "The maximum value of the number. Inclusive."
+                                          ).optional().nullable(),
+                                          minimum: z.number().describe(
+                                            "The minimum value of the number. Inclusive."
+                                          ).optional().nullable(),
+                                          multipleOf: z.number().describe(
+                                            "A number that the value must be a multiple of."
+                                          ).optional().nullable(),
+                                          enum: z.array(z.number()).max(500).optional()
+                                        }).describe(
+                                          "Validation rules for numeric array elements."
+                                        )
+                                      }),
+                                      z.object({
+                                        stringOptions: z.never().optional(),
+                                        numberOptions: z.never().optional(),
+                                        booleanOptions: z.object({
+                                          enum: z.array(
+                                            z.boolean()
+                                          ).max(2).optional()
+                                        }).describe(
+                                          "Validation rules for boolean array elements."
+                                        )
+                                      })
+                                    ])
+                                  ).describe(
+                                    "Type of items allowed in the array."
+                                  ).optional()
+                                }).describe(
+                                  "Validation rules for array properties."
+                                )
+                              })
+                            ])
+                          )
+                        ).describe(
+                          "Definition of object properties and their validation rules."
+                        ).optional()
+                      }).describe(
+                        "Validation configuration for the object input."
+                      ).optional()
+                    }).describe("Object input field settings.")
+                  }),
+                  z.object({
+                    stringOptions: z.never().optional(),
+                    numberOptions: z.never().optional(),
+                    booleanOptions: z.never().optional(),
+                    arrayOptions: z.never().optional(),
+                    objectOptions: z.never().optional(),
+                    paymentOptions: z.never().optional(),
+                    schedulingOptions: z.never().optional(),
+                    addressOptions: z.never().optional(),
+                    wixFileOptions: z.intersection(
+                      z.object({
+                        componentType: z.enum([
+                          "UNKNOWN_COMPONENT_TYPE",
+                          "FILE_UPLOAD",
+                          "SIGNATURE"
+                        ]).describe(
+                          "Component type of the file input field."
+                        ).optional(),
+                        validation: z.object({
+                          fileLimit: z.number().int().describe(
+                            "Maximum number of files that can be uploaded."
+                          ).min(1).max(30).optional(),
+                          uploadFileFormats: z.array(
+                            z.enum([
+                              "VIDEO",
+                              "IMAGE",
+                              "AUDIO",
+                              "DOCUMENT",
+                              "ARCHIVE",
+                              "MODEL_3D"
+                            ])
+                          ).max(6).optional()
+                        }).describe(
+                          "Validation configuration for the file input."
+                        ).optional()
+                      }),
+                      z.xor([
+                        z.object({
+                          fileUploadOptions: z.never().optional(),
+                          signatureOptions: z.never().optional()
+                        }),
+                        z.object({
+                          signatureOptions: z.never().optional(),
+                          fileUploadOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            buttonText: z.string().describe(
+                              "Text displayed on the upload button."
+                            ).max(500).optional().nullable(),
+                            explanationText: z.string().describe(
+                              "Custom text displayed when a file is uploaded. If not specified, the file name is shown."
+                            ).max(255).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe(
+                            "File upload component settings."
+                          )
+                        }),
+                        z.object({
+                          fileUploadOptions: z.never().optional(),
+                          signatureOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            imageUploadEnabled: z.boolean().describe(
+                              "Whether image upload is enabled for the signature field."
+                            ).optional(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media item."
+                            ).optional()
+                          }).describe("Signature component settings.")
+                        })
+                      ])
+                    ).describe(
+                      "File input field settings. Files are uploaded to the [Media Manager](https://support.wix.com/en/article/wix-media-about-the-media-manager)."
+                    )
+                  }),
+                  z.object({
+                    stringOptions: z.never().optional(),
+                    numberOptions: z.never().optional(),
+                    booleanOptions: z.never().optional(),
+                    arrayOptions: z.never().optional(),
+                    objectOptions: z.never().optional(),
+                    wixFileOptions: z.never().optional(),
+                    schedulingOptions: z.never().optional(),
+                    addressOptions: z.never().optional(),
+                    paymentOptions: z.intersection(
+                      z.object({
+                        componentType: z.enum([
+                          "UNKNOWN_COMPONENT_TYPE",
+                          "CHECKBOX_GROUP",
+                          "DONATION_INPUT",
+                          "PAYMENT_INPUT",
+                          "FIXED_PAYMENT"
+                        ]).describe(
+                          "Component type of the payment input field."
+                        ).optional(),
+                        validation: z.object({
+                          products: z.array(
+                            z.intersection(
+                              z.object({
+                                _id: z.string().describe("Product ID.").regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional(),
+                                productType: z.enum(["SHIPPABLE", "DIGITAL"]).describe("Product type.").optional(),
+                                priceType: z.enum([
+                                  "FIXED_PRICE",
+                                  "DYNAMIC_PRICE"
+                                ]).describe("Price type.").optional(),
+                                quantityLimit: z.object({
+                                  minimum: z.number().int().describe(
+                                    "Minimum quantity that must be selected for this product."
+                                  ).min(1).max(1e5).optional().nullable(),
+                                  maximum: z.number().int().describe(
+                                    "Maximum quantity that can be selected for this product."
+                                  ).min(1).max(1e5).optional().nullable()
+                                }).describe(
+                                  "Limits on how many units of this product can be selected."
+                                ).optional()
+                              }),
+                              z.xor([
+                                z.object({
+                                  fixedPriceOptions: z.never().optional(),
+                                  dynamicPriceOptions: z.never().optional()
+                                }),
+                                z.object({
+                                  dynamicPriceOptions: z.never().optional(),
+                                  fixedPriceOptions: z.object({
+                                    price: z.string().describe(
+                                      'Fixed price of the product.\n\nSpecified as a decimal string with period as decimal separator. For example, `"3.99"`.'
+                                    ).optional()
+                                  }).describe(
+                                    "Configuration for products with fixed pricing."
+                                  )
+                                }),
+                                z.object({
+                                  fixedPriceOptions: z.never().optional(),
+                                  dynamicPriceOptions: z.object({
+                                    minPrice: z.string().describe(
+                                      'Minimum price of the product.\n\nSpecified as a decimal string with period as decimal separator. For example, `"1.00"`.'
+                                    ).optional(),
+                                    maxPrice: z.string().describe(
+                                      'Maximum monetary price of the product.\n\nSpecified as a decimal string with period as decimal separator. For example, `"10.00"`.\n\nIf not specified, there is no upper limit on the price.'
+                                    ).optional().nullable()
+                                  }).describe(
+                                    "Configuration for products with variable pricing within a range."
+                                  )
+                                })
+                              ])
+                            )
+                          ).min(1).max(100).optional(),
+                          minItems: z.number().int().describe(
+                            "Minimum number of different products that must be selected."
+                          ).min(0).max(100).optional().nullable(),
+                          maxItems: z.number().int().describe(
+                            "Maximum number of different products that can be selected."
+                          ).min(0).max(100).optional().nullable()
+                        }).describe(
+                          "Validation configuration for the payment input."
+                        ).optional()
+                      }),
+                      z.xor([
+                        z.object({
+                          checkboxGroupOptions: z.never().optional(),
+                          donationInputOptions: z.never().optional(),
+                          paymentInputOptions: z.never().optional(),
+                          fixedPaymentOptions: z.never().optional()
+                        }),
+                        z.object({
+                          donationInputOptions: z.never().optional(),
+                          paymentInputOptions: z.never().optional(),
+                          fixedPaymentOptions: z.never().optional(),
+                          checkboxGroupOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            options: z.array(
+                              z.object({
+                                label: z.string().describe(
+                                  "Selectable option label."
+                                ).max(400).optional().nullable(),
+                                value: z.any().describe(
+                                  "Value stored on submission when this option is selected. Must match a product ID found in the field's products list."
+                                ).optional().nullable(),
+                                _id: z.string().describe(
+                                  "Option ID. Can be used to connect this option with [Wix Multilingual](https://dev.wix.com/docs/api-reference/business-management/multilingual/translation/introduction) for translation."
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional(),
+                                media: z.intersection(
+                                  z.object({}),
+                                  z.xor([
+                                    z.object({
+                                      image: z.never().optional()
+                                    }),
+                                    z.object({
+                                      image: z.string().describe(
+                                        "WixMedia image."
+                                      )
+                                    })
+                                  ])
+                                ).describe(
+                                  "Media content associated with this option, such as an image."
+                                ).optional(),
+                                default: z.boolean().describe(
+                                  "Whether this option is selected by default."
+                                ).optional()
+                              })
+                            ).max(400).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                              "How an image should be resized to fit within its option container.\n\nDefault: `COVER`"
+                            ).optional(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe(
+                            "Checkbox group component settings."
+                          )
+                        }),
+                        z.object({
+                          checkboxGroupOptions: z.never().optional(),
+                          paymentInputOptions: z.never().optional(),
+                          fixedPaymentOptions: z.never().optional(),
+                          donationInputOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            options: z.array(
+                              z.object({
+                                value: z.string().describe(
+                                  "Value stored on submission when this option is selected. Must match a product ID found in the field's products list."
+                                ).regex(
+                                  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                  "Must be a valid GUID"
+                                ).optional(),
+                                default: z.boolean().describe(
+                                  "Whether this option is selected by default."
+                                ).optional()
+                              })
+                            ).max(400).optional(),
+                            customOption: z.object({
+                              label: z.string().describe("Custom option label.").max(350).optional().nullable(),
+                              placeholder: z.string().describe(
+                                "Custom option placeholder text."
+                              ).max(100).optional().nullable()
+                            }).describe(
+                              "Custom option which can be specified by the submitter."
+                            ).optional(),
+                            numberOfColumns: z.enum(["ONE", "TWO", "THREE", "ZERO"]).describe(
+                              "Specifies the number of columns used to display the selections within the component.\n\nDefault: `ONE`"
+                            ).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe(
+                            "Donation input component settings."
+                          )
+                        }),
+                        z.object({
+                          checkboxGroupOptions: z.never().optional(),
+                          donationInputOptions: z.never().optional(),
+                          fixedPaymentOptions: z.never().optional(),
+                          paymentInputOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            placeholder: z.string().describe(
+                              "Placeholder text shown inside the field when it's empty."
+                            ).max(100).optional().nullable(),
+                            default: z.number().describe(
+                              "Default value for the field. This value is pre-populated in the field when the form loads."
+                            ).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe(
+                            "Payment input component settings."
+                          )
+                        }),
+                        z.object({
+                          checkboxGroupOptions: z.never().optional(),
+                          donationInputOptions: z.never().optional(),
+                          paymentInputOptions: z.never().optional(),
+                          fixedPaymentOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            showLabel: z.boolean().describe(
+                              "Whether to display the field label.\n\nDefault: `true`"
+                            ).optional().nullable(),
+                            media: z.intersection(
+                              z.object({}),
+                              z.xor([
+                                z.object({
+                                  image: z.never().optional()
+                                }),
+                                z.object({
+                                  image: z.string().describe("WixMedia image.")
+                                })
+                              ])
+                            ).describe(
+                              "Media content associated with the field, such as an image."
+                            ).optional(),
+                            mediaSettings: z.object({
+                              imagePosition: z.enum(["ABOVE", "BELOW"]).describe(
+                                "Specifies where the image should be displayed relative to the field's label.\nDefault: `BELOW`"
+                              ).optional(),
+                              imageAlignment: z.enum(["LEFT", "CENTER", "RIGHT"]).describe(
+                                "Specifies the image alignment.\nDefault: `CENTER`"
+                              ).optional(),
+                              imageFit: z.enum(["COVER", "CONTAIN"]).describe(
+                                "Specifies how an image should be resized to fit.\nDefault: `COVER`"
+                              ).optional()
+                            }).describe(
+                              "Configuration for the media content."
+                            ).optional()
+                          }).describe(
+                            "Fixed payment component settings."
+                          )
+                        })
+                      ])
+                    ).describe("Payment input field settings.")
+                  }),
+                  z.object({
+                    stringOptions: z.never().optional(),
+                    numberOptions: z.never().optional(),
+                    booleanOptions: z.never().optional(),
+                    arrayOptions: z.never().optional(),
+                    objectOptions: z.never().optional(),
+                    wixFileOptions: z.never().optional(),
+                    paymentOptions: z.never().optional(),
+                    addressOptions: z.never().optional(),
+                    schedulingOptions: z.intersection(
+                      z.object({
+                        componentType: z.enum([
+                          "UNKNOWN_COMPONENT_TYPE",
+                          "APPOINTMENT"
+                        ]).describe(
+                          "Component type of the scheduling field."
+                        ).optional()
+                      }),
+                      z.xor([
+                        z.object({
+                          appointmentOptions: z.never().optional()
+                        }),
+                        z.object({
+                          appointmentOptions: z.intersection(
+                            z.object({
+                              label: z.string().describe("Field label.").max(255).optional().nullable(),
+                              name: z.string().describe("Appointment name.").min(1).max(400).optional().nullable(),
+                              durationInMinutes: z.number().int().describe(
+                                "Duration of the appointment in minutes."
+                              ).min(1).max(44639).optional().nullable(),
+                              manualApprovalRequired: z.boolean().describe(
+                                "Whether appointments require manual approval before confirmation."
+                              ).optional().nullable(),
+                              staffIds: z.array(z.string()).max(220).optional(),
+                              format: z.enum([
+                                "IN_PERSON",
+                                "VIDEO_CONFERENCE",
+                                "PHONE"
+                              ]).describe("Appointment format.").optional(),
+                              description: z.any().describe(
+                                "Additional description or instructions for the field."
+                              ).optional(),
+                              showLabel: z.boolean().describe(
+                                "Whether to display the field label.\n\nDefault: `true`"
+                              ).optional().nullable()
+                            }),
+                            z.xor([
+                              z.object({
+                                inPersonOptions: z.never().optional(),
+                                videoConferenceOptions: z.never().optional(),
+                                phoneOptions: z.never().optional()
+                              }),
+                              z.object({
+                                videoConferenceOptions: z.never().optional(),
+                                phoneOptions: z.never().optional(),
+                                inPersonOptions: z.object({
+                                  locations: z.array(
+                                    z.intersection(
+                                      z.object({}),
+                                      z.xor([
+                                        z.object({
+                                          customAddress: z.never().optional(),
+                                          businessLocationId: z.never().optional()
+                                        }),
+                                        z.object({
+                                          businessLocationId: z.never().optional(),
+                                          customAddress: z.string().describe(
+                                            "Custom address specified as a text string."
+                                          ).max(512)
+                                        }),
+                                        z.object({
+                                          customAddress: z.never().optional(),
+                                          businessLocationId: z.string().describe(
+                                            "ID of a predefined business [location](https://dev.wix.com/docs/rest/crm/members-contacts/locations/locations/introduction)."
+                                          ).regex(
+                                            /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                                            "Must be a valid GUID"
+                                          )
+                                        })
+                                      ])
+                                    )
+                                  ).min(1).max(1).optional()
+                                }).describe(
+                                  "Configuration for in-person appointments."
+                                )
+                              }),
+                              z.object({
+                                inPersonOptions: z.never().optional(),
+                                phoneOptions: z.never().optional(),
+                                videoConferenceOptions: z.object({
+                                  description: z.string().describe(
+                                    "Description or instructions for video conference appointments."
+                                  ).max(512).optional().nullable()
+                                }).describe(
+                                  "Configuration for video conference appointments."
+                                )
+                              }),
+                              z.object({
+                                inPersonOptions: z.never().optional(),
+                                videoConferenceOptions: z.never().optional(),
+                                phoneOptions: z.object({
+                                  description: z.string().describe(
+                                    "Description or instructions for phone appointments."
+                                  ).max(512).optional().nullable()
+                                }).describe(
+                                  "Configuration for phone appointments."
+                                )
+                              })
+                            ])
+                          ).describe(
+                            "Appointment component settings."
+                          )
+                        })
+                      ])
+                    ).describe("Scheduling input field settings.")
+                  }),
+                  z.object({
+                    stringOptions: z.never().optional(),
+                    numberOptions: z.never().optional(),
+                    booleanOptions: z.never().optional(),
+                    arrayOptions: z.never().optional(),
+                    objectOptions: z.never().optional(),
+                    wixFileOptions: z.never().optional(),
+                    paymentOptions: z.never().optional(),
+                    schedulingOptions: z.never().optional(),
+                    addressOptions: z.intersection(
+                      z.object({
+                        componentType: z.enum([
+                          "UNKNOWN_COMPONENT_TYPE",
+                          "MULTILINE_ADDRESS"
+                        ]).describe(
+                          "Component type of the multiline address field."
+                        ).optional(),
+                        validation: z.object({
+                          allowedCountries: z.array(z.string()).min(0).max(200).optional(),
+                          fields: z.object({
+                            subdivision: z.object({
+                              required: z.boolean().describe(
+                                "Whether the field is required."
+                              ).optional()
+                            }).describe("Subdivision settings.").optional(),
+                            city: z.object({
+                              required: z.boolean().describe(
+                                "Whether the field is required."
+                              ).optional()
+                            }).describe("City settings.").optional(),
+                            postalCode: z.object({
+                              required: z.boolean().describe(
+                                "Whether the field is required."
+                              ).optional()
+                            }).describe("Postal code settings.").optional(),
+                            streetName: z.object({
+                              required: z.boolean().describe(
+                                "Whether the field is required."
+                              ).optional()
+                            }).describe("Street name settings.").optional(),
+                            streetNumber: z.object({
+                              required: z.boolean().describe(
+                                "Whether the field is required."
+                              ).optional()
+                            }).describe("Street number settings.").optional(),
+                            addressLine: z.object({
+                              required: z.boolean().describe(
+                                "Whether the field is required."
+                              ).optional()
+                            }).describe("Address line settings.").optional(),
+                            addressLine2: z.object({
+                              required: z.boolean().describe(
+                                "Whether the field is required."
+                              ).optional()
+                            }).describe("Address line 2 settings.").optional(),
+                            country: z.object({
+                              required: z.boolean().describe(
+                                "Whether the field is required."
+                              ).optional()
+                            }).describe("Country settings.").optional()
+                          }).describe(
+                            "Customization configuration for individual address field components."
+                          ).optional()
+                        }).describe(
+                          "Validation configuration for the multiline address input."
+                        ).optional()
+                      }),
+                      z.xor([
+                        z.object({
+                          multilineAddressOptions: z.never().optional()
+                        }),
+                        z.object({
+                          multilineAddressOptions: z.object({
+                            label: z.string().describe("Field label.").max(350).optional().nullable(),
+                            description: z.any().describe(
+                              "Additional description or instructions for the field."
+                            ).optional(),
+                            showCountryFlags: z.boolean().describe(
+                              "Whether to display country flags in the country selection."
+                            ).optional(),
+                            defaultCountryConfig: z.intersection(
+                              z.object({
+                                type: z.enum([
+                                  "UNKNOWN_DEFAULT_COUNTRY",
+                                  "BY_IP",
+                                  "COUNTRY"
+                                ]).describe("Default country type.").optional()
+                              }),
+                              z.xor([
+                                z.object({
+                                  countryOptions: z.never().optional()
+                                }),
+                                z.object({
+                                  countryOptions: z.string().describe(
+                                    "Country code for the pre-selected default country. Two-letter country code in ISO-3166 alpha-2 format."
+                                  )
+                                })
+                              ])
+                            ).describe(
+                              "Default country configuration for the address field."
+                            ).optional(),
+                            fieldSettings: z.object({
+                              addressLine2: z.object({
+                                show: z.boolean().describe(
+                                  "Whether to display the address line 2 field."
+                                ).optional()
+                              }).describe(
+                                "Configuration for the address line 2 field."
+                              ).optional()
+                            }).describe("Fields settings.").optional(),
+                            autocompleteEnabled: z.boolean().describe(
+                              "Whether autocomplete is enabled for the address line field."
+                            ).optional(),
+                            showAddressLabels: z.boolean().describe(
+                              "Flag identifying whether to show or hide the address labels.\nDefault: true"
+                            ).optional().nullable(),
+                            showLabel: z.boolean().describe(
+                              "Flag identifying whether to show or hide the label.\nDefault: true"
+                            ).optional().nullable()
+                          }).describe(
+                            "Multiline address component settings."
+                          )
+                        })
+                      ])
+                    ).describe("Address input field settings.")
+                  })
+                ])
+              ).describe(
+                "Configuration for input fields that collect user data."
+              )
+            }),
+            z.object({
+              inputOptions: z.never().optional(),
+              displayOptions: z.intersection(
+                z.object({
+                  displayFieldType: z.enum([
+                    "UNKNOWN_FIELD_TYPE",
+                    "RICH_CONTENT",
+                    "PAGE_NAVIGATION",
+                    "LOGIN_BAR"
+                  ]).describe(
+                    "Type of display field that determines its appearance and behavior."
+                  ).optional()
+                }),
+                z.xor([
+                  z.object({
+                    richContentOptions: z.never().optional(),
+                    pageNavigationOptions: z.never().optional()
+                  }),
+                  z.object({
+                    pageNavigationOptions: z.never().optional(),
+                    richContentOptions: z.object({
+                      richContent: z.any().describe(
+                        "Rich content to display in the field."
+                      ).optional(),
+                      maxShownParagraphs: z.number().int().describe(
+                        "Maximum number of paragraphs to show initially.\nAdditional content is hidden behind an expandable section. If not specified, all content is visible."
+                      ).optional().nullable()
+                    }).describe(
+                      "Configuration for rich content display fields."
+                    )
+                  }),
+                  z.object({
+                    richContentOptions: z.never().optional(),
+                    pageNavigationOptions: z.object({
+                      nextPageText: z.string().describe(
+                        "Text displayed on the button when it navigates to the next page.\nOnly applicable when the button is not on the final form page."
+                      ).max(65).optional().nullable(),
+                      previousPageText: z.string().describe(
+                        "Text displayed on the button when it navigates to the previous page.\nOnly applicable when the button is not on the first form page."
+                      ).max(65).optional().nullable(),
+                      submitText: z.string().describe(
+                        "Text displayed on the button when it submits the form.\nOnly applicable when the button is on the final form page."
+                      ).max(65).optional().nullable()
+                    }).describe(
+                      "Configuration for page navigation display fields such as navigation or submit buttons."
+                    )
+                  })
+                ])
+              ).describe(
+                "Configuration for display fields that show information without collecting input."
+              )
+            })
+          ])
+        )
+      ).max(100).optional(),
+      steps: z.array(
+        z.object({
+          _id: z.string().describe("Step ID.").regex(
+            /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+            "Must be a valid GUID"
+          ).optional(),
+          name: z.string().describe("Name of the step.").max(200).optional().nullable(),
+          hidden: z.boolean().describe("Whether the step is hidden.").optional(),
+          layout: z.object({
+            large: z.object({
+              items: z.array(
+                z.intersection(
+                  z.object({
+                    row: z.number().int().describe(
+                      "Row position in the grid where this item is placed."
+                    ).optional().nullable(),
+                    column: z.number().int().describe(
+                      "Column position in the grid where this item is placed."
+                    ).optional().nullable(),
+                    width: z.number().int().describe("Width of the item in grid units.").optional().nullable(),
+                    height: z.number().int().describe("Height of the item in grid units.").optional().nullable()
+                  }),
+                  z.xor([
+                    z.object({ fieldId: z.never().optional() }),
+                    z.object({
+                      fieldId: z.string().describe(
+                        "ID of the form field to be positioned in the layout."
+                      ).regex(
+                        /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                        "Must be a valid GUID"
+                      )
+                    })
+                  ])
+                )
+              ).max(500).optional(),
+              columns: z.number().int().describe("Number of columns in the layout grid.").optional().nullable(),
+              rowHeight: z.number().int().describe(
+                "Height of each row in the layout grid, measured in pixels."
+              ).optional().nullable(),
+              margin: z.object({
+                horizontal: z.number().int().describe("Horizontal spacing in pixels.").optional().nullable(),
+                vertical: z.number().int().describe("Vertical spacing in pixels.").optional().nullable()
+              }).describe(
+                "Margin spacing configuration for the form elements."
+              ).optional(),
+              padding: z.object({
+                horizontal: z.number().int().describe("Horizontal spacing in pixels.").optional().nullable(),
+                vertical: z.number().int().describe("Vertical spacing in pixels.").optional().nullable()
+              }).describe(
+                "Padding spacing inside form elements in pixels."
+              ).optional()
+            }).describe(
+              "Layout configuration for large screen breakpoints (desktop)."
+            ).optional(),
+            medium: z.object({
+              items: z.array(
+                z.intersection(
+                  z.object({
+                    row: z.number().int().describe(
+                      "Row position in the grid where this item is placed."
+                    ).optional().nullable(),
+                    column: z.number().int().describe(
+                      "Column position in the grid where this item is placed."
+                    ).optional().nullable(),
+                    width: z.number().int().describe("Width of the item in grid units.").optional().nullable(),
+                    height: z.number().int().describe("Height of the item in grid units.").optional().nullable()
+                  }),
+                  z.xor([
+                    z.object({ fieldId: z.never().optional() }),
+                    z.object({
+                      fieldId: z.string().describe(
+                        "ID of the form field to be positioned in the layout."
+                      ).regex(
+                        /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                        "Must be a valid GUID"
+                      )
+                    })
+                  ])
+                )
+              ).max(500).optional(),
+              columns: z.number().int().describe("Number of columns in the layout grid.").optional().nullable(),
+              rowHeight: z.number().int().describe(
+                "Height of each row in the layout grid, measured in pixels."
+              ).optional().nullable(),
+              margin: z.object({
+                horizontal: z.number().int().describe("Horizontal spacing in pixels.").optional().nullable(),
+                vertical: z.number().int().describe("Vertical spacing in pixels.").optional().nullable()
+              }).describe(
+                "Margin spacing configuration for the form elements."
+              ).optional(),
+              padding: z.object({
+                horizontal: z.number().int().describe("Horizontal spacing in pixels.").optional().nullable(),
+                vertical: z.number().int().describe("Vertical spacing in pixels.").optional().nullable()
+              }).describe(
+                "Padding spacing inside form elements in pixels."
+              ).optional()
+            }).describe(
+              "Layout configuration for medium screen breakpoints (tablet)."
+            ).optional(),
+            small: z.object({
+              items: z.array(
+                z.intersection(
+                  z.object({
+                    row: z.number().int().describe(
+                      "Row position in the grid where this item is placed."
+                    ).optional().nullable(),
+                    column: z.number().int().describe(
+                      "Column position in the grid where this item is placed."
+                    ).optional().nullable(),
+                    width: z.number().int().describe("Width of the item in grid units.").optional().nullable(),
+                    height: z.number().int().describe("Height of the item in grid units.").optional().nullable()
+                  }),
+                  z.xor([
+                    z.object({ fieldId: z.never().optional() }),
+                    z.object({
+                      fieldId: z.string().describe(
+                        "ID of the form field to be positioned in the layout."
+                      ).regex(
+                        /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+                        "Must be a valid GUID"
+                      )
+                    })
+                  ])
+                )
+              ).max(500).optional(),
+              columns: z.number().int().describe("Number of columns in the layout grid.").optional().nullable(),
+              rowHeight: z.number().int().describe(
+                "Height of each row in the layout grid, measured in pixels."
+              ).optional().nullable(),
+              margin: z.object({
+                horizontal: z.number().int().describe("Horizontal spacing in pixels.").optional().nullable(),
+                vertical: z.number().int().describe("Vertical spacing in pixels.").optional().nullable()
+              }).describe(
+                "Margin spacing configuration for the form elements."
+              ).optional(),
+              padding: z.object({
+                horizontal: z.number().int().describe("Horizontal spacing in pixels.").optional().nullable(),
+                vertical: z.number().int().describe("Vertical spacing in pixels.").optional().nullable()
+              }).describe(
+                "Padding spacing inside form elements in pixels."
+              ).optional()
+            }).describe(
+              "Layout configuration for small screen breakpoints (mobile)."
+            ).optional()
+          }).describe(
+            "Layout configuration that defines how form fields are arranged within this step."
+          ).optional()
+        })
+      ).max(100).optional(),
+      name: z.string().describe("Display name of the template.").min(1).max(200).optional().nullable(),
+      submitSettings: z.intersection(
+        z.object({
+          submitSuccessAction: z.enum(["NO_ACTION", "THANK_YOU_MESSAGE", "REDIRECT", "POPUP"]).describe(
+            "Action that's triggered after a form is successfully submitted."
+          ).optional()
+        }),
+        z.xor([
+          z.object({
+            thankYouMessageOptions: z.never().optional(),
+            redirectOptions: z.never().optional(),
+            popupOptions: z.never().optional()
+          }),
+          z.object({
+            redirectOptions: z.never().optional(),
+            popupOptions: z.never().optional(),
+            thankYouMessageOptions: z.object({
+              durationInSeconds: z.number().int().describe(
+                "Duration in seconds before the thank you message automatically disappears.\nIf set to 0, the message remains visible until manually dismissed."
+              ).optional().nullable(),
+              richContent: z.any().describe(
+                "Rich content message displayed to users after successful form submission."
+              ).optional()
+            }).describe(
+              "Configuration for displaying a thank you message after submission."
+            )
+          }),
+          z.object({
+            thankYouMessageOptions: z.never().optional(),
+            popupOptions: z.never().optional(),
+            redirectOptions: z.object({
+              redirectUrl: z.string().describe(
+                "URL to which the user should be redirected after successfully submitting the form."
+              ).max(2e3).optional().nullable(),
+              target: z.enum(["UNKNOWN_TARGET", "SELF", "BLANK"]).describe(
+                "How the redirect URL should be opened in the browser."
+              ).optional()
+            }).describe(
+              "Configuration for redirecting submitters to a URL after submission."
+            )
+          }),
+          z.object({
+            thankYouMessageOptions: z.never().optional(),
+            redirectOptions: z.never().optional(),
+            popupOptions: z.object({
+              popupId: z.string().describe(
+                "ID of the site popup to open after successful form submission."
+              ).min(1).max(100).optional()
+            }).describe(
+              "Configuration for displaying a popup after submission."
+            )
+          })
+        ])
+      ).describe(
+        "Settings that determine what happens after the form is submitted, such as displaying a\nthank you message, redirecting to a URL, or opening a popup."
+      ).optional(),
+      _createdDate: z.date().describe("Date and time the form template was created.").optional().nullable(),
+      _updatedDate: z.date().describe("Date and time the form template was last updated.").optional().nullable(),
+      fieldGroups: z.array(
+        z.object({
+          _id: z.string().describe("Id of group, on layout").regex(
+            /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+            "Must be a valid GUID"
+          ).optional(),
+          label: z.string().describe("Label of group").max(350).optional().nullable()
+        })
+      ).max(50).optional(),
+      requiredIndicatorProperties: z.object({
+        requiredIndicator: z.enum(["ASTERISK", "TEXT", "NONE"]).describe(
+          "Type of visual indicator used to mark required fields."
+        ).optional(),
+        requiredIndicatorPlacement: z.enum(["AFTER_FIELD_TITLE", "BEFORE_FIELD_TITLE"]).describe(
+          "Position where the required indicator appears relative to the field title."
+        ).optional()
+      }).describe(
+        "How required fields are marked on the form: the indicator that's displayed, for example an\nasterisk, and its placement relative to the field title."
+      ).optional(),
+      autoFillContact: z.enum(["MEMBER_DATA", "FORM_INPUT"]).describe(
+        "Source used to autofill contact fields in forms created from this template.\n\nDefault: `FORM_INPUT`"
+      ).optional(),
+      quizSettings: z.intersection(
+        z.object({
+          message: z.any().describe("Confirmation message text.").optional(),
+          resultsDisplay: z.enum([
+            "DO_NOT_DISPLAY",
+            "SCORE",
+            "PASSING_STATUS",
+            "SCORE_AND_PASSING_STATUS"
+          ]).describe(
+            "How to display quiz results in the confirmation page.\nDefault: `DO_NOT_DISPLAY`"
+          ).optional()
+        }),
+        z.intersection(
+          z.xor([
+            z.object({
+              passingScorePoints: z.never().optional(),
+              passingScorePercentage: z.never().optional()
+            }),
+            z.object({
+              passingScorePercentage: z.never().optional(),
+              passingScorePoints: z.number().describe("Score required to pass the quiz (in points).").min(0)
+            }),
+            z.object({
+              passingScorePoints: z.never().optional(),
+              passingScorePercentage: z.number().describe(
+                "Score required to pass the quiz as a percentage (0-100)."
+              ).min(0).max(100)
+            })
+          ]),
+          z.xor([
+            z.object({
+              passingStatusOptions: z.never().optional(),
+              scoreAndPassingStatusOptions: z.never().optional()
+            }),
+            z.object({
+              scoreAndPassingStatusOptions: z.never().optional(),
+              passingStatusOptions: z.object({
+                passMessage: z.any().describe(
+                  "Message displayed when the user passes the quiz."
+                ).optional(),
+                failMessage: z.any().describe(
+                  "Message displayed when the user fails the quiz."
+                ).optional()
+              }).describe(
+                "Configuration for displaying only the pass/fail message."
+              )
+            }),
+            z.object({
+              passingStatusOptions: z.never().optional(),
+              scoreAndPassingStatusOptions: z.object({
+                passMessage: z.any().describe(
+                  "Message displayed when the user passes the quiz."
+                ).optional(),
+                failMessage: z.any().describe(
+                  "Message displayed when the user fails the quiz."
+                ).optional()
+              }).describe(
+                "Configuration for displaying both the score and pass/fail message."
+              )
+            })
+          ])
+        )
+      ).describe(
+        "Quiz configuration applied to forms created from this template."
+      ).optional()
+    })
+  ).optional()
+});
+export {
+  ListFormTemplatesRequest,
+  ListFormTemplatesResponse
+};
+//# sourceMappingURL=schemas.mjs.map