@encatch/schema 0.0.1 → 0.1.1

package/dist/esm/index.js

@@ -1,12 +1,891 @@
-// Main entry point for encatch-typescript schemas
-export * from './schemas/fields/field-schema';
-export * from './schemas/fields/answer-schema';
-export * from './schemas/fields/form-schema';
-export * from './schemas/fields/form-properties-schema';
-export * from './schemas/fields/other-screen-schema';
-export * from './schemas/fields/theme-schema';
-export * from './schemas/fields/translations-schema';
-export * from './schemas/fields/auto-trigger-schema';
-// Re-export Zod for convenience (consumers should add zod to their dependencies)
-export { z } from 'zod';
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/schemas/fields/field-schema.ts
+import { z } from "zod";
+var questionTypeSchema = z.enum([
+  "rating",
+  "single_choice",
+  "nps",
+  "nested_selection",
+  "multiple_choice_multiple",
+  "short_answer",
+  "long_text",
+  "annotation"
+]).describe("Enumeration of all supported question types for form fields");
+var validationRuleSchema = z.object({
+  type: z.enum([
+    "required",
+    "min",
+    "max",
+    "minLength",
+    "maxLength",
+    "pattern",
+    "email",
+    "url",
+    "custom"
+  ]).describe("Type of validation rule to apply"),
+  value: z.union([z.string(), z.number(), z.boolean()]).optional().describe("Value for the validation rule (string, number, or boolean)"),
+  message: z.string().optional().describe("Custom error message when validation fails"),
+  describe: z.string().max(500).optional().describe("LLM tool call description for this validation rule")
+}).describe("Schema defining validation rules for question responses");
+var visibilityConditionSchema = z.object({
+  field: z.string().describe("ID of the field to check against"),
+  operator: z.enum([
+    "equals",
+    "not_equals",
+    "contains",
+    "not_contains",
+    "greater_than",
+    "less_than",
+    "is_empty",
+    "is_not_empty"
+  ]).describe("Comparison operator for the condition"),
+  value: z.union([z.string(), z.number(), z.boolean()]).optional().describe("Value to compare against (string, number, or boolean)"),
+  describe: z.string().max(500).optional().describe("LLM tool call description for this visibility condition")
+}).describe(
+  "Schema defining conditions that control when questions are visible"
+);
+var sectionSchema = z.object({
+  id: z.uuid().describe("Unique identifier for the section"),
+  title: z.string().min(1).max(200).describe("Display title for the section"),
+  question_ids: z.array(z.uuid()).min(1).describe("Array of question IDs that belong to this section")
+}).describe("Schema defining sections that organize questions into logical groups");
+var questionStatusSchema = z.enum(["D", "P", "A", "S"]);
+var ratingDisplayStyleSchema = z.enum([
+  "star",
+  "heart",
+  "thumbs-up",
+  "diamond",
+  "emoji",
+  "emoji-exp"
+]);
+var ratingRepresentationSizeSchema = z.enum([
+  "small",
+  "medium",
+  "large"
+]);
+var multipleChoiceDisplayStyleSchema = z.enum([
+  "radio",
+  "list",
+  "chip",
+  "dropdown"
+]);
+var multipleChoiceMultipleDisplayStyleSchema = z.enum([
+  "checkbox",
+  "list",
+  "chip"
+]);
+var choiceOrderOptionSchema = z.enum([
+  "randomize",
+  "flip",
+  "rotate",
+  "ascending",
+  "none"
+]);
+var questionSchema = z.object({
+  id: z.uuid().describe("Unique identifier for the question"),
+  type: questionTypeSchema.describe(
+    "The type of question (rating, single_choice, etc.)"
+  ),
+  title: z.string().min(1).max(200).describe("The main title/question text displayed to users"),
+  description: z.string().max(1e3).optional().describe("Optional detailed description or help text"),
+  describe: z.string().max(2e3).optional().describe(
+    "LLM tool call description for better AI understanding and context"
+  ),
+  required: z.boolean().default(false).describe("Whether this question must be answered"),
+  errorMessage: z.string().max(500).optional().describe("Custom error message when validation fails"),
+  validations: z.array(validationRuleSchema).optional().default([]).describe("Array of validation rules to apply"),
+  visibility: z.array(visibilityConditionSchema).optional().default([]).describe("Conditions that control when this question is shown"),
+  isFixed: z.boolean().describe("Whether this question position is fixed or can be reordered"),
+  sectionId: z.string().uuid().optional().describe("ID of the section this question belongs to"),
+  status: questionStatusSchema.describe(
+    "Current status of the question (Draft, Published, etc.)"
+  )
+}).describe("Base schema for all question types with common properties");
+var ratingQuestionSchema = questionSchema.extend({
+  type: z.literal(questionTypeSchema.enum.rating).describe("Must be exactly 'rating'"),
+  showLabels: z.boolean().optional().describe("Whether to show min/max labels"),
+  minLabel: z.string().max(100).optional().describe("Label for the minimum rating value"),
+  maxLabel: z.string().max(100).optional().describe("Label for the maximum rating value"),
+  displayStyle: ratingDisplayStyleSchema.optional().describe("Visual style for rating display"),
+  numberOfRatings: z.number().int().min(1).max(10).describe("Number of rating options (1-10)"),
+  representationSize: ratingRepresentationSizeSchema.optional().describe("Size of rating visual elements"),
+  color: z.string().regex(/^#[0-9A-F]{6}$/i, "Must be a valid hex color").optional().describe("Hex color for rating elements")
+}).describe("Schema for rating questions with customizable display options");
+var annotationQuestionSchema = questionSchema.extend({
+  type: z.literal(questionTypeSchema.enum.annotation).describe("Must be exactly 'annotation'"),
+  annotationText: z.string().max(1e3).optional().describe("Text to display when annotation is provided"),
+  noAnnotationText: z.string().max(500).optional().describe("Text to display when no annotation is provided")
+}).describe(
+  "Schema for annotation questions that provide additional context or instructions"
+);
+var questionOptionSchema = z.object({
+  id: z.uuid().describe("Unique identifier for this option"),
+  value: z.string().min(1).max(100).describe("The internal value used for this option"),
+  label: z.string().min(1).max(200).describe("The display text shown to users for this option"),
+  describe: z.string().max(500).optional().describe(
+    "LLM tool call description providing context about this option"
+  ),
+  imageUrl: z.string().url().optional().describe("Optional image URL to display with this option")
+}).describe("Schema for individual options in choice-based questions");
+var nestedOptionSchema = z.lazy(
+  () => z.object({
+    id: z.string().uuid().describe("Unique identifier for this nested option"),
+    value: z.string().min(1).max(100).describe("The internal value used for this nested option"),
+    label: z.string().min(1).max(200).describe("The display text shown for this nested option"),
+    describe: z.string().max(500).optional().describe("LLM tool call description for this nested option context"),
+    imageUrl: z.string().url().optional().describe("Optional image URL for this nested option"),
+    hint: z.string().max(500).optional().describe(
+      "Optional hint text to help users understand this nested option"
+    ),
+    children: z.array(nestedOptionSchema).optional().default([]).describe("Array of child options for hierarchical structure")
+  }).describe("Schema for nested options with hierarchical structure support")
+);
+var multipleChoiceSingleQuestionSchema = questionSchema.extend({
+  type: z.literal(questionTypeSchema.enum.single_choice).describe("Must be exactly 'single_choice'"),
+  displayStyle: multipleChoiceDisplayStyleSchema.optional().describe("Visual style for displaying options"),
+  randomizeOptions: z.boolean().optional().default(false).describe("Whether to randomize the order of options"),
+  options: z.array(questionOptionSchema).min(1).max(50).describe("Array of options for user selection (1-50 options)")
+}).describe("Schema for single-choice multiple selection questions");
+var multipleChoiceMultipleQuestionSchema = questionSchema.extend({
+  type: z.literal(questionTypeSchema.enum.multiple_choice_multiple).describe("Must be exactly 'multiple_choice_multiple'"),
+  displayStyle: multipleChoiceMultipleDisplayStyleSchema.optional().describe("Visual style for displaying multiple options"),
+  minSelections: z.number().int().min(0).optional().describe("Minimum number of options that must be selected"),
+  maxSelections: z.number().int().min(1).optional().describe("Maximum number of options that can be selected"),
+  randomizeOptions: z.boolean().optional().default(false).describe("Whether to randomize the order of options"),
+  options: z.array(questionOptionSchema).min(1).max(50).describe("Array of options for user selection (1-50 options)")
+}).refine(
+  (data) => {
+    if (data.minSelections !== void 0 && data.maxSelections !== void 0) {
+      return data.minSelections <= data.maxSelections;
+    }
+    return true;
+  },
+  {
+    message: "minSelections cannot be greater than maxSelections",
+    path: ["minSelections"]
+    // Point to minSelections field for the error
+  }
+).describe(
+  "Schema for multiple-choice questions allowing multiple selections"
+);
+var npsQuestionSchema = questionSchema.extend({
+  type: z.literal(questionTypeSchema.enum.nps).describe("Must be exactly 'nps'"),
+  min: z.literal(0).describe("NPS always starts at 0"),
+  max: z.literal(10).describe("NPS always ends at 10"),
+  minLabel: z.string().max(100).optional().describe("Label for the minimum NPS value (0)"),
+  maxLabel: z.string().max(100).optional().describe("Label for the maximum NPS value (10)"),
+  scaleLabels: z.record(z.string().regex(/^\d+$/).transform(Number).refine((val) => val >= 0 && val <= 10), z.string().max(50)).optional().describe("Custom labels for specific NPS values (0-10)"),
+  prepopulatedValue: z.number().int().min(0).max(10).optional().describe("Default value to pre-select (0-10)")
+}).refine(
+  (data) => {
+    if (data.scaleLabels) {
+      const keys = Object.keys(data.scaleLabels).map(Number);
+      return keys.every((key) => key >= 0 && key <= 10);
+    }
+    return true;
+  },
+  {
+    message: "scaleLabels keys must be between 0 and 10 (inclusive)",
+    path: ["scaleLabels"]
+  }
+).describe("Schema for Net Promoter Score questions with 0-10 scale");
+var shortAnswerQuestionSchema = questionSchema.extend({
+  type: z.literal(questionTypeSchema.enum.short_answer).describe("Must be exactly 'short_answer'"),
+  maxCharacters: z.number().int().min(1).max(1e4).optional().describe("Maximum number of characters allowed"),
+  minCharacters: z.number().int().min(0).optional().describe("Minimum number of characters required"),
+  placeholder: z.string().max(200).optional().describe("Placeholder text shown in the input field"),
+  enableRegexValidation: z.boolean().optional().default(false).describe("Whether to enable regex pattern validation"),
+  regexPattern: z.string().optional().describe("Regular expression pattern for validation"),
+  enableEnhanceWithAi: z.boolean().optional().default(false).describe("Whether to enable AI enhancement features"),
+  promptTemplate: z.string().max(2e3).optional().describe("Template for AI enhancement prompts"),
+  cooldownSeconds: z.number().int().min(0).max(3600).optional().describe("Cooldown period between AI enhancements (0-3600 seconds)"),
+  maxEnhancements: z.number().int().min(1).max(10).optional().describe("Maximum number of AI enhancements allowed"),
+  maxTokenAllowed: z.number().int().min(1).max(1e4).optional().describe("Maximum tokens allowed for AI processing"),
+  minCharactersToEnhance: z.number().int().min(1).optional().describe("Minimum characters needed to trigger AI enhancement")
+}).refine(
+  (data) => {
+    if (data.minCharacters !== void 0 && data.maxCharacters !== void 0) {
+      return data.minCharacters <= data.maxCharacters;
+    }
+    return true;
+  },
+  {
+    message: "minCharacters cannot be greater than maxCharacters",
+    path: ["minCharacters"]
+  }
+).refine(
+  (data) => {
+    if (data.enableRegexValidation && !data.regexPattern) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "regexPattern is required when enableRegexValidation is true",
+    path: ["regexPattern"]
+  }
+).refine(
+  (data) => {
+    if (data.enableEnhanceWithAi && !data.promptTemplate) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "promptTemplate is required when enableEnhanceWithAi is true",
+    path: ["promptTemplate"]
+  }
+).describe("Schema for short answer questions with optional AI enhancement");
+var longAnswerQuestionSchema = questionSchema.extend({
+  type: z.literal(questionTypeSchema.enum.long_text).describe("Must be exactly 'long_text'"),
+  maxCharacters: z.number().int().min(1).max(5e4).optional().describe(
+    "Maximum number of characters allowed (higher limit for long text)"
+  ),
+  minCharacters: z.number().int().min(0).optional().describe("Minimum number of characters required"),
+  rows: z.number().int().min(1).max(20).optional().describe("Number of textarea rows to display (1-20)"),
+  placeholder: z.string().max(500).optional().describe("Placeholder text for the textarea (longer for long text)"),
+  enableEnhanceWithAi: z.boolean().optional().default(false).describe("Whether to enable AI enhancement features"),
+  promptTemplate: z.string().max(2e3).optional().describe("Template for AI enhancement prompts"),
+  cooldownSeconds: z.number().int().min(0).max(3600).optional().describe("Cooldown period between AI enhancements (0-3600 seconds)"),
+  maxEnhancements: z.number().int().min(1).max(10).optional().describe("Maximum number of AI enhancements allowed"),
+  maxTokenAllowed: z.number().int().min(1).max(25e3).optional().describe(
+    "Maximum tokens allowed for AI processing (higher for long text)"
+  )
+}).refine(
+  (data) => {
+    if (data.minCharacters !== void 0 && data.maxCharacters !== void 0) {
+      return data.minCharacters <= data.maxCharacters;
+    }
+    return true;
+  },
+  {
+    message: "minCharacters cannot be greater than maxCharacters",
+    path: ["minCharacters"]
+  }
+).refine(
+  (data) => {
+    if (data.enableEnhanceWithAi && !data.promptTemplate) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "promptTemplate is required when enableEnhanceWithAi is true",
+    path: ["promptTemplate"]
+  }
+).describe(
+  "Schema for long answer questions with rich text support and AI enhancement"
+);
+var nestedDropdownQuestionSchema = questionSchema.extend({
+  type: z.literal(questionTypeSchema.enum.nested_selection).describe("Must be exactly 'nested_selection'"),
+  placeholder: z.string().max(200).optional().describe("Placeholder text for the nested dropdown"),
+  options: z.array(nestedOptionSchema).min(1).max(100).describe(
+    "Array of nested options for hierarchical selection (1-100 options)"
+  ),
+  displayStyle: z.literal("list").describe("Fixed display style for nested dropdowns"),
+  choiceOrderOption: choiceOrderOptionSchema.optional().default("none").describe("How to order the nested choices"),
+  preserveLastChoices: z.number().int().min(0).max(10).optional().describe("Number of choice levels to preserve (0-10)"),
+  prepopulatedValue: z.string().max(1e3).optional().describe("Default value to pre-populate"),
+  allowOther: z.boolean().optional().default(false).describe('Whether to allow custom "other" options'),
+  otherColumnName: z.string().max(100).optional().describe('Column name for storing custom "other" values'),
+  maxDepth: z.number().int().min(1).max(10).optional().describe("Maximum nesting depth allowed (1-10)"),
+  cascadeLabels: z.boolean().optional().default(false).describe("Whether to cascade labels from parent options")
+}).refine(
+  (data) => {
+    if (data.allowOther && !data.otherColumnName) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "otherColumnName is required when allowOther is true",
+    path: ["otherColumnName"]
+  }
+).describe(
+  "Schema for nested dropdown questions with hierarchical option structure"
+);
+var combinedQuestionSchema = z.discriminatedUnion("type", [
+  ratingQuestionSchema,
+  annotationQuestionSchema,
+  multipleChoiceSingleQuestionSchema,
+  multipleChoiceMultipleQuestionSchema,
+  npsQuestionSchema,
+  shortAnswerQuestionSchema,
+  longAnswerQuestionSchema,
+  nestedDropdownQuestionSchema
+]);
+
+// src/schemas/fields/answer-schema.ts
+import { z as z2 } from "zod";
+var SimpleAnswerSchema = z2.object({
+  type: z2.literal("simple").describe("Indicates this is a simple answer with a single value"),
+  value: z2.union([z2.string(), z2.number(), z2.boolean()]).describe("The answer value - can be text, number, or boolean")
+}).describe(
+  "A simple answer containing a single value like text, number, or boolean"
+);
+var ChoiceAnswerSchema = z2.object({
+  type: z2.literal("choice").describe("Indicates this is a single-choice answer"),
+  selectedOptionId: z2.string().describe("The ID of the selected option from the available choices")
+}).describe(
+  "A single-choice answer where the user selects one option from a list"
+);
+var MultipleChoiceAnswerSchema = z2.object({
+  type: z2.literal("multiple_choice").describe("Indicates this is a multiple-choice answer"),
+  selectedOptionIds: z2.array(z2.string()).describe(
+    "Array of IDs for all selected options from the available choices"
+  )
+}).describe(
+  "A multiple-choice answer where the user can select multiple options from a list"
+);
+var ScaleAnswerSchema = z2.object({
+  type: z2.literal("scale").describe("Indicates this is a scale/rating answer"),
+  value: z2.number().describe(
+    "The numerical value representing the position on the scale (e.g., 1-5, 1-10)"
+  )
+}).describe(
+  "A scale answer where the user selects a numerical value on a scale"
+);
+var ContinuousSumAnswerSchema = z2.object({
+  type: z2.literal("continuous_sum").describe("Indicates this is a continuous sum answer"),
+  values: z2.array(
+    z2.object({
+      optionId: z2.string().describe("The ID of the option being rated"),
+      value: z2.number().describe("The numerical value assigned to this option")
+    })
+  ).describe(
+    "Array of option-value pairs where the sum of all values represents a total allocation"
+  )
+}).describe(
+  "A continuous sum answer where users distribute values across multiple options that add up to a total"
+);
+var RankingAnswerSchema = z2.object({
+  type: z2.literal("ranking").describe("Indicates this is a ranking answer"),
+  ranks: z2.array(
+    z2.object({
+      optionId: z2.string().describe("The ID of the option being ranked"),
+      rank: z2.number().describe(
+        "The rank position of this option (lower numbers indicate higher preference)"
+      )
+    })
+  ).describe(
+    "Array of option-rank pairs showing the user's preference ordering"
+  )
+}).describe(
+  "A ranking answer where users order options by preference or priority"
+);
+var TextAnswerSchema = z2.object({
+  type: z2.literal("text").describe("Indicates this is a text-based answer"),
+  values: z2.array(
+    z2.object({
+      fieldId: z2.string().describe("The ID of the text field"),
+      text: z2.string().describe("The text content entered by the user")
+    })
+  ).describe("Array of field-text pairs for multiple text input fields")
+}).describe(
+  "A text answer containing responses to one or more text input fields"
+);
+var AnswerSchema = z2.discriminatedUnion("type", [
+  SimpleAnswerSchema,
+  ChoiceAnswerSchema,
+  MultipleChoiceAnswerSchema,
+  ScaleAnswerSchema,
+  ContinuousSumAnswerSchema,
+  RankingAnswerSchema,
+  TextAnswerSchema
+]).describe(
+  "A union of all possible answer types discriminated by the 'type' field"
+);
+
+// src/schemas/fields/form-schema.ts
+import { z as z3 } from "zod";
+var surveyTypeSchema = z3.enum(["R", "O"]).describe("Enumeration of feedback types: R=Recurring, O=One-time");
+var yesNoSchema = z3.enum(["Y", "N"]).describe("Yes/No enumeration using Y/N values");
+var recurringUnitSchema = z3.enum(["minutes", "hours", "days", "weeks", "months", "years"]).describe("Time units for recurring feedback schedules");
+var frequencyAndSchedulingPropertiesSchema = z3.object({
+  surveyType: surveyTypeSchema.describe("Type of feedback: R for recurring, O for one-time"),
+  showOnce: yesNoSchema.describe("Whether the feedback should be shown only once per user"),
+  stopWhenResponsesCount: z3.string().regex(/^\d+$/, "Must be a valid number string").describe("Stop feedback when this number of responses is reached (as string)"),
+  recurringValue: z3.string().regex(/^\d+$/, "Must be a valid number string").describe("Value for recurring schedule (e.g., every 15 days)"),
+  recurringUnit: recurringUnitSchema.describe("Time unit for recurring schedule"),
+  startDate: z3.string().regex(
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(\+|\-)\d{2}:\d{2}$/,
+    "Must be a valid ISO date string with timezone"
+  ).describe("Start date and time for the feedback in ISO format"),
+  stopDate: z3.string().regex(
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(\+|\-)\d{2}:\d{2}$/,
+    "Must be a valid ISO date string with timezone"
+  ).describe("Stop date and time for the feedback in ISO format")
+}).refine(
+  (data) => {
+    if (data.surveyType === "O" && data.showOnce === "N") {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "One-time feedback must have showOnce set to 'Y'",
+    path: ["showOnce"]
+  }
+).refine(
+  (data) => {
+    if (data.surveyType === "R") {
+      const value = parseInt(data.recurringValue);
+      return value > 0;
+    }
+    return true;
+  },
+  {
+    message: "Recurring feedback must have a positive recurring value",
+    path: ["recurringValue"]
+  }
+).refine(
+  (data) => {
+    const start = new Date(data.startDate);
+    const stop = new Date(data.stopDate);
+    return stop > start;
+  },
+  {
+    message: "Stop date must be after start date",
+    path: ["stopDate"]
+  }
+).describe("Schema defining frequency and scheduling properties for feedback");
+var externalPublishingPropertiesSchema = z3.object({
+  isShareable: z3.boolean().describe("Whether the feedback results can be shared externally"),
+  isEmailShareable: z3.boolean().describe("Whether the feedback can be shared via email")
+}).describe("Schema defining external publishing and sharing properties for feedback");
+var publicationStatusSchema = z3.enum(["P", "D", "A"]).describe("Publication status: P=Published, D=Draft, A=Archived");
+var feedbackConfigurationSchema = z3.object({
+  form_title: z3.string().describe("Title of the feedback form"),
+  form_description: z3.string().describe("Description of the feedback form"),
+  duration: z3.object({
+    from: z3.string().regex(
+      /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(\+|\-)\d{2}:\d{2}$/,
+      "Must be a valid ISO date string with timezone"
+    ).describe("Start date and time for the feedback duration"),
+    to: z3.string().regex(
+      /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(\+|\-)\d{2}:\d{2}$/,
+      "Must be a valid ISO date string with timezone"
+    ).describe("End date and time for the feedback duration")
+  }).describe("Duration period for the feedback"),
+  is_published: publicationStatusSchema.describe("Publication status of the feedback form")
+}).refine(
+  (data) => {
+    const start = new Date(data.duration.from);
+    const end = new Date(data.duration.to);
+    return end > start;
+  },
+  {
+    message: "End date must be after start date",
+    path: ["duration", "to"]
+  }
+).describe("Schema defining feedback configuration properties");
+
+// src/schemas/fields/form-properties-schema.ts
+import { z as z8 } from "zod";
+
+// src/schemas/fields/translations-schema.ts
+import { z as z4 } from "zod";
+var translationEntrySchema = z4.object({
+  text: z4.string().min(1).describe("Translated text content"),
+  context: z4.string().optional().describe("Optional context for translators")
+}).describe("Translation entry with translated text");
+var ratingTranslationsSchema = z4.object({
+  title: translationEntrySchema.describe("Question title translation"),
+  description: translationEntrySchema.optional().describe("Question description translation"),
+  errorMessage: translationEntrySchema.optional().describe("Error message translation"),
+  minLabel: translationEntrySchema.optional().describe("Minimum rating label translation"),
+  maxLabel: translationEntrySchema.optional().describe("Maximum rating label translation")
+}).describe("Translation schema for rating questions");
+var singleChoiceTranslationsSchema = z4.object({
+  title: translationEntrySchema.describe("Question title translation"),
+  description: translationEntrySchema.optional().describe("Question description translation"),
+  errorMessage: translationEntrySchema.optional().describe("Error message translation"),
+  placeholder: translationEntrySchema.optional().describe("Input placeholder translation"),
+  options: z4.record(z4.string(), z4.object({
+    label: translationEntrySchema.describe("Option label translation"),
+    hint: translationEntrySchema.optional().describe("Option hint translation")
+  })).describe("Option translations keyed by option ID")
+}).describe("Translation schema for single choice questions");
+var multipleChoiceTranslationsSchema = z4.object({
+  title: translationEntrySchema.describe("Question title translation"),
+  description: translationEntrySchema.optional().describe("Question description translation"),
+  errorMessage: translationEntrySchema.optional().describe("Error message translation"),
+  placeholder: translationEntrySchema.optional().describe("Input placeholder translation"),
+  options: z4.record(z4.string(), z4.object({
+    label: translationEntrySchema.describe("Option label translation"),
+    hint: translationEntrySchema.optional().describe("Option hint translation")
+  })).describe("Option translations keyed by option ID")
+}).describe("Translation schema for multiple choice questions");
+var npsTranslationsSchema = z4.object({
+  title: translationEntrySchema.describe("Question title translation"),
+  description: translationEntrySchema.optional().describe("Question description translation"),
+  errorMessage: translationEntrySchema.optional().describe("Error message translation"),
+  minLabel: translationEntrySchema.optional().describe("Minimum NPS label (0) translation"),
+  maxLabel: translationEntrySchema.optional().describe("Maximum NPS label (10) translation"),
+  scaleLabels: z4.record(z4.number().int().min(0).max(10), translationEntrySchema).optional().describe("Scale label translations for specific NPS values (0-10)")
+}).describe("Translation schema for NPS questions");
+var shortAnswerTranslationsSchema = z4.object({
+  title: translationEntrySchema.describe("Question title translation"),
+  description: translationEntrySchema.optional().describe("Question description translation"),
+  errorMessage: translationEntrySchema.optional().describe("Error message translation"),
+  placeholder: translationEntrySchema.optional().describe("Input placeholder translation")
+}).describe("Translation schema for short answer questions");
+var longAnswerTranslationsSchema = z4.object({
+  title: translationEntrySchema.describe("Question title translation"),
+  description: translationEntrySchema.optional().describe("Question description translation"),
+  errorMessage: translationEntrySchema.optional().describe("Error message translation"),
+  placeholder: translationEntrySchema.optional().describe("Textarea placeholder translation")
+}).describe("Translation schema for long answer questions");
+var nestedSelectionTranslationsSchema = z4.object({
+  title: translationEntrySchema.describe("Question title translation"),
+  description: translationEntrySchema.optional().describe("Question description translation"),
+  errorMessage: translationEntrySchema.optional().describe("Error message translation"),
+  placeholder: translationEntrySchema.optional().describe("Dropdown placeholder translation"),
+  nestedOptions: z4.record(z4.string(), z4.object({
+    label: translationEntrySchema.describe("Nested option label translation"),
+    hint: translationEntrySchema.optional().describe("Nested option hint translation")
+  })).describe("Nested option translations keyed by option ID")
+}).describe("Translation schema for nested selection questions");
+var annotationTranslationsSchema = z4.object({
+  title: translationEntrySchema.describe("Question title translation"),
+  description: translationEntrySchema.optional().describe("Question description translation"),
+  errorMessage: translationEntrySchema.optional().describe("Error message translation"),
+  annotationText: translationEntrySchema.optional().describe("Annotation display text translation"),
+  noAnnotationText: translationEntrySchema.optional().describe("No annotation display text translation")
+}).describe("Translation schema for annotation questions");
+var questionTranslationsSchema = z4.discriminatedUnion("type", [
+  z4.object({ type: z4.literal("rating"), translations: ratingTranslationsSchema }),
+  z4.object({ type: z4.literal("single_choice"), translations: singleChoiceTranslationsSchema }),
+  z4.object({ type: z4.literal("multiple_choice_multiple"), translations: multipleChoiceTranslationsSchema }),
+  z4.object({ type: z4.literal("nps"), translations: npsTranslationsSchema }),
+  z4.object({ type: z4.literal("short_answer"), translations: shortAnswerTranslationsSchema }),
+  z4.object({ type: z4.literal("long_text"), translations: longAnswerTranslationsSchema }),
+  z4.object({ type: z4.literal("nested_selection"), translations: nestedSelectionTranslationsSchema }),
+  z4.object({ type: z4.literal("annotation"), translations: annotationTranslationsSchema })
+]).describe("Discriminated union of all question type translation schemas");
+var languageTranslationsSchema = z4.object({
+  languageCode: z4.string().describe("Language code matching LanguagesSchema values"),
+  questions: z4.record(z4.string(), questionTranslationsSchema).describe("Question translations keyed by question ID")
+}).describe("Language-specific translation set keyed by question IDs");
+var translationsSchema = z4.object({
+  defaultLanguage: z4.string().describe("Default/fallback language code"),
+  languages: z4.array(languageTranslationsSchema).min(1).describe("Available language translations"),
+  version: z4.string().optional().describe("Translation version for cache management")
+}).describe("Complete translation schema keyed by question IDs");
+var _TranslationProvider = class _TranslationProvider {
+  constructor(translations) {
+    this.translations = translations;
+  }
+  /**
+   * Get translations for a specific question in a specific language
+   */
+  getQuestionTranslations(questionId, languageCode) {
+    const languageData = this.translations.languages.find(
+      (lang) => lang.languageCode === languageCode
+    );
+    if (!languageData) {
+      const defaultLang = this.translations.languages.find(
+        (lang) => lang.languageCode === this.translations.defaultLanguage
+      );
+      if (!defaultLang) return null;
+      return defaultLang.questions[questionId] || null;
+    }
+    return languageData.questions[questionId] || null;
+  }
+  /**
+   * Get a specific translation text
+   */
+  getTranslationText(questionId, languageCode, path) {
+    const questionTranslations = this.getQuestionTranslations(questionId, languageCode);
+    if (!questionTranslations) return null;
+    let current = questionTranslations.translations;
+    for (const key of path) {
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return null;
+      }
+    }
+    if (current && typeof current === "object" && "text" in current) {
+      return current.text;
+    }
+    return null;
+  }
+  /**
+   * Get all available languages
+   */
+  getAvailableLanguages() {
+    return this.translations.languages.map((lang) => lang.languageCode);
+  }
+  /**
+   * Check if a language is supported
+   */
+  isLanguageSupported(languageCode) {
+    return this.translations.languages.some((lang) => lang.languageCode === languageCode);
+  }
+  /**
+   * Get the default language
+   */
+  getDefaultLanguage() {
+    return this.translations.defaultLanguage;
+  }
+};
+__name(_TranslationProvider, "TranslationProvider");
+var TranslationProvider = _TranslationProvider;
+function createTranslationProvider(translations) {
+  return new TranslationProvider(translations);
+}
+__name(createTranslationProvider, "createTranslationProvider");
+
+// src/schemas/fields/other-screen-schema.ts
+import { z as z5 } from "zod";
+var WelcomeScreenFieldsSchema = z5.object({
+  title: z5.string().min(1).max(200).describe("The main title displayed on the welcome screen"),
+  description: z5.string().min(1).max(1e3).describe("Description text shown on the welcome screen"),
+  buttonLabel: z5.string().min(1).max(50).describe("Text displayed on the welcome screen button")
+}).describe("Schema for welcome screen configuration fields");
+var EndScreenFieldsSchema = z5.object({
+  title: z5.string().min(1).max(200).describe("The main title displayed on the end screen"),
+  message: z5.string().min(1).max(1e3).describe("Message text shown on the end screen"),
+  buttonLabel: z5.string().min(1).max(50).describe("Text displayed on the end screen button"),
+  dismissBehavior: z5.enum(["fade", "manual"]).describe("How the end screen should be dismissed (fade out or manual dismissal)"),
+  fadeDuration: z5.number().int().min(0).max(1e4).describe("Duration in milliseconds for fade dismissal (0-10000)")
+}).describe("Schema for end screen configuration fields");
+var WelcomeFieldsTranslationSchema = z5.object({
+  title: z5.string().min(1).max(200).describe("Translated title text for welcome screen"),
+  description: z5.string().min(1).max(1e3).describe("Translated description text for welcome screen"),
+  buttonLabel: z5.string().min(1).max(50).describe("Translated text for the welcome button label")
+}).describe("Schema for welcome screen translation fields");
+var EndFieldsTranslationSchema = z5.object({
+  buttonLabel: z5.string().min(1).max(50).describe("Translated text for the end button label"),
+  title: z5.string().min(1).max(200).describe("Translated title text for end screen"),
+  message: z5.string().min(1).max(1e3).describe("Translated message text for end screen")
+}).describe("Schema for end screen translation fields");
+var OtherFieldsSchema = z5.object({
+  pagination: z5.boolean().describe("Whether to show pagination for multi-page forms"),
+  questionNumber: z5.boolean().describe("Whether to display question numbers"),
+  pageTitle: z5.boolean().describe("Whether to show page titles in multi-page forms"),
+  blockerFeedback: z5.boolean().describe("Whether to show blocker feedback for validation errors"),
+  submitButtonLabel: z5.string().min(1).max(50).describe("Text for the submit button"),
+  previousButtonLabel: z5.string().min(1).max(50).describe("Text for the previous button in pagination"),
+  nextButtonLabel: z5.string().min(1).max(50).describe("Text for the next button in pagination")
+}).describe("Schema for other form configuration fields");
+var LanguageFieldSchema = z5.object({
+  value: z5.string().min(1).max(10).describe("Language code (e.g., 'en', 'es', 'fr')"),
+  label: z5.string().min(1).max(50).describe("Display name for the language (e.g., 'English', 'Spanish', 'French')"),
+  isFixed: z5.boolean().default(false).describe("Whether this language is fixed and cannot be deleted by users")
+}).describe("Schema for individual language field with value, label, and fixed status");
+var LanguagesSchema = z5.array(LanguageFieldSchema).describe("Schema for array of available languages");
+var OtherFieldsTranslationSchema = z5.object({
+  submitButtonLabel: z5.string().min(1).max(50).describe("Translated text for the submit button"),
+  previousButtonLabel: z5.string().min(1).max(50).describe("Translated text for the previous button in pagination"),
+  nextButtonLabel: z5.string().min(1).max(50).describe("Translated text for the next button in pagination")
+}).describe("Schema for other form configuration field translations");
+
+// src/schemas/fields/theme-schema.ts
+import { z as z6 } from "zod";
+var positionSchema = z6.enum([
+  "top-left",
+  "top-center",
+  "top-right",
+  "middle-left",
+  "middle-center",
+  "middle-right",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right"
+]).describe("Available positions for widget placement");
+var featureSettingsSchema = z6.object({
+  darkOverlay: z6.boolean().describe("Whether to show a dark overlay behind the widget"),
+  closeButton: z6.boolean().describe("Whether to display a close button on the widget"),
+  progressBar: z6.boolean().describe("Whether to show a progress bar indicating completion status"),
+  showBranding: z6.boolean().describe("Whether to display branding elements on the widget"),
+  customPosition: z6.boolean().describe("Whether custom positioning is enabled"),
+  customIconPosition: z6.boolean().describe("Whether custom icon positioning is enabled")
+}).describe("Feature settings controlling widget UI behavior and appearance");
+var themeColorsSchema = z6.object({
+  brandColor: z6.string().regex(/^#([0-9A-F]{3}|[0-9A-F]{6})$/i, "Must be a valid hex color (e.g., #3366CC)").describe("Primary brand color in hex format"),
+  overlayColor: z6.string().regex(/^#([0-9A-F]{3}|[0-9A-F]{6})$/i, "Must be a valid hex color (e.g., #FFFFFF)").describe("Overlay background color in hex format"),
+  textColor: z6.string().regex(/^#([0-9A-F]{3}|[0-9A-F]{6})$/i, "Must be a valid hex color (e.g., #333333)").describe("Primary text color in hex format"),
+  backgroundColor: z6.union([
+    z6.string().regex(/^#([0-9A-F]{3}|[0-9A-F]{6})$/i),
+    z6.string().regex(/^rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(?:,\s*[01](?:\.\d+)?)?\s*\)$/i)
+  ]).describe("Background color in hex format or rgba format (e.g., #1A1A1A or rgba(255,255,255, 1))")
+}).describe("Color scheme for a single theme");
+var themesSchema = z6.object({
+  light: themeColorsSchema,
+  dark: themeColorsSchema
+}).describe("Complete theme configuration with light and dark variants");
+var themeConfigurationSchema = z6.object({
+  themes: themesSchema.describe("Color themes for light and dark modes"),
+  featureSettings: featureSettingsSchema.describe("UI feature settings controlling widget behavior"),
+  selectedPosition: positionSchema.describe("Selected position for the main widget"),
+  selectedIconPosition: positionSchema.describe("Selected position for the widget icon")
+}).describe("Complete theme and UI configuration including colors, features, and positioning");
+
+// src/schemas/fields/auto-trigger-schema.ts
+import { z as z7 } from "zod";
+var audienceSegmentSchema = z7.object({
+  id: z7.string().describe("Unique identifier for the audience segment"),
+  name: z7.string().min(1).max(200).describe("Display name for the audience segment"),
+  isImportant: z7.boolean().describe("Whether this segment is marked as important for targeting"),
+  when: z7.string().describe("Timing condition for when to trigger the audience segment"),
+  who: z7.string().describe("User criteria or conditions defining who belongs to this segment")
+}).describe("Schema defining an audience segment for targeting");
+var audienceTriggerPropertiesSchema = z7.object({
+  isAuto: z7.boolean().describe("Whether automatic triggering is enabled for this audience"),
+  isManual: z7.boolean().describe("Whether manual triggering is enabled for this audience"),
+  segments: z7.array(audienceSegmentSchema).min(0).describe("Array of audience segments for targeting conditions")
+}).refine(
+  (data) => {
+    return data.isAuto || data.isManual;
+  },
+  {
+    message: "At least one of isAuto or isManual must be true",
+    path: ["isAuto"]
+  }
+).describe("Schema defining audience trigger properties for form targeting");
+
+// src/schemas/fields/form-properties-schema.ts
+var otherConfigurationPropertiesSchema = z8.discriminatedUnion("isEnabled", [
+  // When other configuration is disabled
+  z8.object({
+    isEnabled: z8.literal(false).describe("Whether other configuration properties are enabled"),
+    otherFields: OtherFieldsSchema.optional().describe("Other form configuration fields including pagination, buttons, and display options"),
+    translations: OtherFieldsTranslationSchema.optional().describe("Translations for other configuration field labels and buttons")
+  }),
+  // When other configuration is enabled
+  z8.object({
+    isEnabled: z8.literal(true).describe("Whether other configuration properties are enabled"),
+    otherFields: OtherFieldsSchema.describe("Other form configuration fields including pagination, buttons, and display options"),
+    translations: OtherFieldsTranslationSchema.describe("Translations for other configuration field labels and buttons")
+  })
+]).describe("Schema for other configuration properties including fields and translations");
+var welcomeScreenPropertiesSchema = z8.discriminatedUnion("isEnabled", [
+  // When welcome screen is disabled
+  z8.object({
+    isEnabled: z8.literal(false).describe("Whether welcome screen is enabled"),
+    welcomeFields: WelcomeScreenFieldsSchema.optional().describe("Welcome screen configuration fields including title, description, and button label"),
+    translations: WelcomeFieldsTranslationSchema.optional().describe("Translations for welcome screen content")
+  }),
+  // When welcome screen is enabled
+  z8.object({
+    isEnabled: z8.literal(true).describe("Whether welcome screen is enabled"),
+    welcomeFields: WelcomeScreenFieldsSchema.describe("Welcome screen configuration fields including title, description, and button label"),
+    translations: WelcomeFieldsTranslationSchema.describe("Translations for welcome screen content")
+  })
+]).describe("Schema for welcome screen properties including fields and translations");
+var endScreenPropertiesSchema = z8.discriminatedUnion("isEnabled", [
+  // When end screen is disabled
+  z8.object({
+    isEnabled: z8.literal(false).describe("Whether end screen is enabled"),
+    endFields: EndScreenFieldsSchema.optional().describe("End screen configuration fields including title, message, button label, and dismissal behavior"),
+    translations: EndFieldsTranslationSchema.optional().describe("Translations for end screen content")
+  }),
+  // When end screen is enabled
+  z8.object({
+    isEnabled: z8.literal(true).describe("Whether end screen is enabled"),
+    endFields: EndScreenFieldsSchema.describe("End screen configuration fields including title, message, button label, and dismissal behavior"),
+    translations: EndFieldsTranslationSchema.describe("Translations for end screen content")
+  })
+]).describe("Schema for end screen properties including fields and translations");
+var appearancePropertiesSchema = z8.object({
+  themeConfiguration: themeConfigurationSchema.describe("Theme configuration including colors, features, and positioning")
+}).describe("Schema for appearance properties including theme configuration");
+var formPropertiesSchema = z8.object({
+  feedback_configuration_id: z8.uuid().describe("Unique identifier for the feedback configuration"),
+  feedback_configuration: feedbackConfigurationSchema.describe("Configuration properties for the feedback form"),
+  questionnaire_fields: z8.object({
+    questions: z8.record(z8.uuid(), combinedQuestionSchema).describe("Collection of questions keyed by their UUID identifiers"),
+    sections: z8.array(sectionSchema).describe("Array of sections that organize questions into logical groups"),
+    selected_languages: LanguagesSchema.describe("Array of languages selected for this questionnaire"),
+    translations: translationsSchema.describe("Multi-language translations for questions and form content")
+  }).describe("Fields defining the questionnaire structure, questions, sections, selected languages, and translations"),
+  frequency_and_scheduling_properties: frequencyAndSchedulingPropertiesSchema.describe("Properties controlling when and how often the feedback is shown"),
+  external_publishing_properties: externalPublishingPropertiesSchema.describe("Properties controlling external sharing and publishing of feedback results"),
+  audience_trigger_properties: audienceTriggerPropertiesSchema.describe("Properties defining audience targeting and trigger conditions for the feedback form"),
+  other_configuration_properties: otherConfigurationPropertiesSchema.describe("Additional configuration properties including form display options and translations"),
+  welcome_screen_properties: welcomeScreenPropertiesSchema.describe("Welcome screen configuration including content and translations"),
+  end_screen_properties: endScreenPropertiesSchema.describe("End screen configuration including content, dismissal behavior, and translations"),
+  appearance_properties: appearancePropertiesSchema.describe("Appearance configuration including themes, colors, and UI feature settings")
+}).describe("Complete schema for all feedback-level properties including scheduling, publishing, audience targeting, configuration, screens, and appearance");
+
+// src/index.ts
+import { z as z9 } from "zod";
+export {
+  AnswerSchema,
+  ChoiceAnswerSchema,
+  ContinuousSumAnswerSchema,
+  EndFieldsTranslationSchema,
+  EndScreenFieldsSchema,
+  LanguageFieldSchema,
+  LanguagesSchema,
+  MultipleChoiceAnswerSchema,
+  OtherFieldsSchema,
+  OtherFieldsTranslationSchema,
+  RankingAnswerSchema,
+  ScaleAnswerSchema,
+  SimpleAnswerSchema,
+  TextAnswerSchema,
+  TranslationProvider,
+  WelcomeFieldsTranslationSchema,
+  WelcomeScreenFieldsSchema,
+  annotationQuestionSchema,
+  annotationTranslationsSchema,
+  appearancePropertiesSchema,
+  audienceSegmentSchema,
+  audienceTriggerPropertiesSchema,
+  choiceOrderOptionSchema,
+  combinedQuestionSchema,
+  createTranslationProvider,
+  endScreenPropertiesSchema,
+  externalPublishingPropertiesSchema,
+  featureSettingsSchema,
+  feedbackConfigurationSchema,
+  formPropertiesSchema,
+  frequencyAndSchedulingPropertiesSchema,
+  languageTranslationsSchema,
+  longAnswerQuestionSchema,
+  longAnswerTranslationsSchema,
+  multipleChoiceDisplayStyleSchema,
+  multipleChoiceMultipleDisplayStyleSchema,
+  multipleChoiceMultipleQuestionSchema,
+  multipleChoiceSingleQuestionSchema,
+  multipleChoiceTranslationsSchema,
+  nestedDropdownQuestionSchema,
+  nestedOptionSchema,
+  nestedSelectionTranslationsSchema,
+  npsQuestionSchema,
+  npsTranslationsSchema,
+  otherConfigurationPropertiesSchema,
+  positionSchema,
+  publicationStatusSchema,
+  questionOptionSchema,
+  questionSchema,
+  questionStatusSchema,
+  questionTranslationsSchema,
+  questionTypeSchema,
+  ratingDisplayStyleSchema,
+  ratingQuestionSchema,
+  ratingRepresentationSizeSchema,
+  ratingTranslationsSchema,
+  recurringUnitSchema,
+  sectionSchema,
+  shortAnswerQuestionSchema,
+  shortAnswerTranslationsSchema,
+  singleChoiceTranslationsSchema,
+  surveyTypeSchema,
+  themeColorsSchema,
+  themeConfigurationSchema,
+  themesSchema,
+  translationEntrySchema,
+  translationsSchema,
+  validationRuleSchema,
+  visibilityConditionSchema,
+  welcomeScreenPropertiesSchema,
+  yesNoSchema,
+  z9 as z
+};
+//# sourceMappingURL=index.js.map