@encatch/schema 0.1.15 → 0.1.18

package/dist/esm/index.js

@@ -14,14 +14,14 @@ var questionTypeSchema = z.enum([
   "annotation"
 ]).describe("Enumeration of all supported question types for form fields");
 var QuestionTypes = {
-  RATING: questionTypeSchema.options[0],
-  SINGLE_CHOICE: questionTypeSchema.options[1],
-  NPS: questionTypeSchema.options[2],
-  NESTED_SELECTION: questionTypeSchema.options[3],
-  MULTIPLE_CHOICE_MULTIPLE: questionTypeSchema.options[4],
-  SHORT_ANSWER: questionTypeSchema.options[5],
-  LONG_TEXT: questionTypeSchema.options[6],
-  ANNOTATION: questionTypeSchema.options[7]
+  RATING: "rating",
+  SINGLE_CHOICE: "single_choice",
+  NPS: "nps",
+  NESTED_SELECTION: "nested_selection",
+  MULTIPLE_CHOICE_MULTIPLE: "multiple_choice_multiple",
+  SHORT_ANSWER: "short_answer",
+  LONG_TEXT: "long_text",
+  ANNOTATION: "annotation"
 };
 var validationRuleTypeSchema = z.enum([
   "required",
@@ -35,15 +35,15 @@ var validationRuleTypeSchema = z.enum([
   "custom"
 ]).describe("Enumeration of all supported validation rule types");
 var ValidationRuleTypes = {
-  REQUIRED: validationRuleTypeSchema.options[0],
-  MIN: validationRuleTypeSchema.options[1],
-  MAX: validationRuleTypeSchema.options[2],
-  MIN_LENGTH: validationRuleTypeSchema.options[3],
-  MAX_LENGTH: validationRuleTypeSchema.options[4],
-  PATTERN: validationRuleTypeSchema.options[5],
-  EMAIL: validationRuleTypeSchema.options[6],
-  URL: validationRuleTypeSchema.options[7],
-  CUSTOM: validationRuleTypeSchema.options[8]
+  REQUIRED: "required",
+  MIN: "min",
+  MAX: "max",
+  MIN_LENGTH: "minLength",
+  MAX_LENGTH: "maxLength",
+  PATTERN: "pattern",
+  EMAIL: "email",
+  URL: "url",
+  CUSTOM: "custom"
 };
 var validationRuleSchema = z.object({
   type: validationRuleTypeSchema.describe("Type of validation rule to apply"),
@@ -62,14 +62,14 @@ var visibilityConditionOperatorSchema = z.enum([
   "is_not_empty"
 ]).describe("Enumeration of all supported visibility condition operators");
 var VisibilityConditionOperators = {
-  EQUALS: visibilityConditionOperatorSchema.options[0],
-  NOT_EQUALS: visibilityConditionOperatorSchema.options[1],
-  CONTAINS: visibilityConditionOperatorSchema.options[2],
-  NOT_CONTAINS: visibilityConditionOperatorSchema.options[3],
-  GREATER_THAN: visibilityConditionOperatorSchema.options[4],
-  LESS_THAN: visibilityConditionOperatorSchema.options[5],
-  IS_EMPTY: visibilityConditionOperatorSchema.options[6],
-  IS_NOT_EMPTY: visibilityConditionOperatorSchema.options[7]
+  EQUALS: "equals",
+  NOT_EQUALS: "not_equals",
+  CONTAINS: "contains",
+  NOT_CONTAINS: "not_contains",
+  GREATER_THAN: "greater_than",
+  LESS_THAN: "less_than",
+  IS_EMPTY: "is_empty",
+  IS_NOT_EMPTY: "is_not_empty"
 };
 var visibilityConditionSchema = z.object({
   field: z.string().describe("ID of the field to check against"),
@@ -86,10 +86,10 @@ var sectionSchema = z.object({
 }).describe("Schema defining sections that organize questions into logical groups");
 var questionStatusSchema = z.enum(["D", "P", "A", "S"]);
 var QuestionStatuses = {
-  DRAFT: questionStatusSchema.options[0],
-  PUBLISHED: questionStatusSchema.options[1],
-  ARCHIVED: questionStatusSchema.options[2],
-  SUSPENDED: questionStatusSchema.options[3]
+  DRAFT: "D",
+  PUBLISHED: "P",
+  ARCHIVED: "A",
+  SUSPENDED: "S"
 };
 var ratingDisplayStyleSchema = z.enum([
   "star",
@@ -100,12 +100,12 @@ var ratingDisplayStyleSchema = z.enum([
   "emoji-exp"
 ]);
 var RatingDisplayStyles = {
-  STAR: ratingDisplayStyleSchema.options[0],
-  HEART: ratingDisplayStyleSchema.options[1],
-  THUMBS_UP: ratingDisplayStyleSchema.options[2],
-  DIAMOND: ratingDisplayStyleSchema.options[3],
-  EMOJI: ratingDisplayStyleSchema.options[4],
-  EMOJI_EXP: ratingDisplayStyleSchema.options[5]
+  STAR: "star",
+  HEART: "heart",
+  THUMBS_UP: "thumbs_up",
+  DIAMOND: "diamond",
+  EMOJI: "emoji",
+  EMOJI_EXP: "emoji_exp"
 };
 var ratingRepresentationSizeSchema = z.enum([
   "small",
@@ -113,9 +113,9 @@ var ratingRepresentationSizeSchema = z.enum([
   "large"
 ]);
 var RatingRepresentationSizes = {
-  SMALL: ratingRepresentationSizeSchema.options[0],
-  MEDIUM: ratingRepresentationSizeSchema.options[1],
-  LARGE: ratingRepresentationSizeSchema.options[2]
+  SMALL: "small",
+  MEDIUM: "medium",
+  LARGE: "large"
 };
 var multipleChoiceDisplayStyleSchema = z.enum([
   "radio",
@@ -124,10 +124,10 @@ var multipleChoiceDisplayStyleSchema = z.enum([
   "dropdown"
 ]);
 var MultipleChoiceDisplayStyles = {
-  RADIO: multipleChoiceDisplayStyleSchema.options[0],
-  LIST: multipleChoiceDisplayStyleSchema.options[1],
-  CHIP: multipleChoiceDisplayStyleSchema.options[2],
-  DROPDOWN: multipleChoiceDisplayStyleSchema.options[3]
+  RADIO: "radio",
+  LIST: "list",
+  CHIP: "chip",
+  DROPDOWN: "dropdown"
 };
 var multipleChoiceMultipleDisplayStyleSchema = z.enum([
   "checkbox",
@@ -135,9 +135,9 @@ var multipleChoiceMultipleDisplayStyleSchema = z.enum([
   "chip"
 ]);
 var MultipleChoiceMultipleDisplayStyles = {
-  CHECKBOX: multipleChoiceMultipleDisplayStyleSchema.options[0],
-  LIST: multipleChoiceMultipleDisplayStyleSchema.options[1],
-  CHIP: multipleChoiceMultipleDisplayStyleSchema.options[2]
+  CHECKBOX: "checkbox",
+  LIST: "list",
+  CHIP: "chip"
 };
 var choiceOrderOptionSchema = z.enum([
   "randomize",
@@ -147,11 +147,11 @@ var choiceOrderOptionSchema = z.enum([
   "none"
 ]);
 var ChoiceOrderOptions = {
-  RANDOMIZE: choiceOrderOptionSchema.options[0],
-  FLIP: choiceOrderOptionSchema.options[1],
-  ROTATE: choiceOrderOptionSchema.options[2],
-  ASCENDING: choiceOrderOptionSchema.options[3],
-  NONE: choiceOrderOptionSchema.options[4]
+  RANDOMIZE: "randomize",
+  FLIP: "flip",
+  ROTATE: "rotate",
+  ASCENDING: "ascending",
+  NONE: "none"
 };
 var questionSchema = z.object({
   id: z.string().describe("Unique identifier for the question"),
@@ -325,7 +325,8 @@ var longAnswerQuestionSchema = questionSchema.extend({
   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)"
-  )
+  ),
+  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) {
@@ -475,22 +476,22 @@ var AnswerSchema = z2.discriminatedUnion("type", [
 import { z as z3 } from "zod";
 var surveyTypeSchema = z3.enum(["R", "O"]).describe("Enumeration of feedback types: R=Recurring, O=One-time");
 var SurveyTypes = {
-  RECURRING: surveyTypeSchema.options[0],
-  ONE_TIME: surveyTypeSchema.options[1]
+  RECURRING: "R",
+  ONE_TIME: "O"
 };
 var yesNoSchema = z3.enum(["Y", "N"]).describe("Yes/No enumeration using Y/N values");
 var YesNoValues = {
-  YES: yesNoSchema.options[0],
-  NO: yesNoSchema.options[1]
+  YES: "Y",
+  NO: "N"
 };
 var recurringUnitSchema = z3.enum(["minutes", "hours", "days", "weeks", "months", "years"]).describe("Time units for recurring feedback schedules");
 var RecurringUnits = {
-  MINUTES: recurringUnitSchema.options[0],
-  HOURS: recurringUnitSchema.options[1],
-  DAYS: recurringUnitSchema.options[2],
-  WEEKS: recurringUnitSchema.options[3],
-  MONTHS: recurringUnitSchema.options[4],
-  YEARS: recurringUnitSchema.options[5]
+  MINUTES: "minutes",
+  HOURS: "hours",
+  DAYS: "days",
+  WEEKS: "weeks",
+  MONTHS: "months",
+  YEARS: "years"
 };
 var frequencyAndSchedulingPropertiesSchema = z3.object({
   surveyType: surveyTypeSchema.describe("Type of feedback: R for recurring, O for one-time"),
@@ -546,35 +547,39 @@ var externalPublishingPropertiesSchema = z3.object({
 }).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 PublicationStatuses = {
-  PUBLISHED: publicationStatusSchema.options[0],
-  DRAFT: publicationStatusSchema.options[1],
-  ARCHIVED: publicationStatusSchema.options[2]
+  PUBLISHED: "P",
+  DRAFT: "D",
+  ARCHIVED: "A"
 };
+var durationSchema = z3.object({
+  from: z3.string().describe("Start date and time for the duration (ISO format or custom format)"),
+  to: z3.string().describe("End date and time for the duration (ISO format or custom format)")
+}).describe("Duration range for when something is active");
 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"),
+  duration: durationSchema.refine(
+    (data) => {
+      const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(\+|\-)\d{2}:\d{2}$/;
+      return isoRegex.test(data.from) && isoRegex.test(data.to);
+    },
+    {
+      message: "Duration dates must be in valid ISO format with timezone",
+      path: ["from"]
+    }
+  ).refine(
+    (data) => {
+      const start = new Date(data.from);
+      const end = new Date(data.to);
+      return end > start;
+    },
+    {
+      message: "End date must be after start date",
+      path: ["to"]
+    }
+  ).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");
+}).describe("Schema defining feedback configuration properties");
 
 // src/schemas/fields/form-properties-schema.ts
 import { z as z8 } from "zod";
@@ -737,8 +742,8 @@ __name(createTranslationProvider, "createTranslationProvider");
 import { z as z5 } from "zod";
 var dismissBehaviorSchema = z5.enum(["fade", "manual"]).describe("How the end screen should be dismissed (fade out or manual dismissal)");
 var DismissBehaviors = {
-  FADE: dismissBehaviorSchema.options[0],
-  MANUAL: dismissBehaviorSchema.options[1]
+  FADE: "fade",
+  MANUAL: "manual"
 };
 var WelcomeScreenFieldsSchema = z5.object({
   title: z5.string().min(1).max(200).describe("The main title displayed on the welcome screen"),
@@ -797,20 +802,20 @@ var positionSchema = z6.enum([
   "bottom-right"
 ]).describe("Available positions for widget placement");
 var Positions = {
-  TOP_LEFT: positionSchema.options[0],
-  TOP_CENTER: positionSchema.options[1],
-  TOP_RIGHT: positionSchema.options[2],
-  MIDDLE_LEFT: positionSchema.options[3],
-  MIDDLE_CENTER: positionSchema.options[4],
-  MIDDLE_RIGHT: positionSchema.options[5],
-  BOTTOM_LEFT: positionSchema.options[6],
-  BOTTOM_CENTER: positionSchema.options[7],
-  BOTTOM_RIGHT: positionSchema.options[8]
+  TOP_LEFT: "top-left",
+  TOP_CENTER: "top-center",
+  TOP_RIGHT: "top-right",
+  MIDDLE_LEFT: "middle-left",
+  MIDDLE_CENTER: "middle-center",
+  MIDDLE_RIGHT: "middle-right",
+  BOTTOM_LEFT: "bottom-left",
+  BOTTOM_CENTER: "bottom-center",
+  BOTTOM_RIGHT: "bottom-right"
 };
 var themeModeSchema = z6.enum(["light", "dark"]).describe("Available theme modes for the widget");
 var ThemeModes = {
-  LIGHT: themeModeSchema.options[0],
-  DARK: themeModeSchema.options[1]
+  LIGHT: "light",
+  DARK: "dark"
 };
 var featureSettingsSchema = z6.object({
   darkOverlay: z6.boolean().describe("Whether to show a dark overlay behind the widget"),
@@ -989,13 +994,176 @@ var masterPropertiesSchema = z9.object({
   feedback_interval_duration: z9.number().int().positive().describe("Duration in seconds for feedback interval between two auto triggered feedbacks")
 }).describe("Master properties configuration for global survey settings");
 
-// src/index.ts
+// src/schemas/api/other-schema.ts
 import { z as z10 } from "zod";
+var deviceThemeSchema = z10.enum(["light", "dark", "system"]).describe("Enumeration of supported theme modes");
+var DeviceThemes = {
+  LIGHT: "light",
+  DARK: "dark",
+  SYSTEM: "system"
+};
+var deviceInfoSchema = z10.object({
+  deviceType: z10.string().describe("Type of device being used"),
+  timezone: z10.string().describe("Device timezone (e.g., 'Asia/Calcutta')"),
+  theme: deviceThemeSchema.describe("Current theme mode preference"),
+  os: z10.string().describe("Operating system running on the device"),
+  osVersion: z10.string().describe("Version of the operating system"),
+  appVersion: z10.string().describe("Version of the application"),
+  app: z10.string().describe("Browser or application being used"),
+  language: z10.string().describe("Language preference (e.g., 'en-GB')")
+}).describe("Device information collected from the client");
+var sessionInfoSchema = z10.object({
+  sessionId: z10.string().uuid().describe("Unique session identifier")
+}).describe("Session information for tracking user sessions");
+var deviceSessionInfoSchema = z10.object({
+  deviceInfo: deviceInfoSchema.describe("Device information"),
+  sessionInfo: sessionInfoSchema.describe("Session information")
+}).describe("Combined device and session information");
+var userPropertiesSchema = z10.object({
+  $counter: z10.record(z10.string(), z10.number().int()).describe("Counter properties for user tracking (can be positive or negative)").optional(),
+  $set: z10.record(z10.string(), z10.any()).describe("Properties to set for the user").optional(),
+  $setOnce: z10.record(z10.string(), z10.any()).describe("Properties to set once for the user (won't overwrite existing values)").optional(),
+  $unset: z10.array(z10.string()).describe("Array of property names to unset/remove from the user").optional()
+}).passthrough().describe("User properties including counters, set operations, and other dynamic data");
+var userInfoSchema = z10.object({
+  userName: z10.string().email().describe("User's email address as username"),
+  properties: userPropertiesSchema.describe("User properties and counters")
+}).describe("User information including identification and properties");
+
+// src/schemas/api/submit-feedback-schema.ts
+import { z as z11 } from "zod";
+var userActionSchema = z11.enum(["V", "S"]).describe("User action: V for view, S for submit");
+var UserActions = {
+  VIEW: "V",
+  SUBMIT: "S"
+};
+var formConfigSchema = z11.object({
+  feedbackIdentifier: z11.string().uuid().describe("Unique identifier for the feedback instance"),
+  feedbackConfigurationId: z11.string().uuid().describe("Unique identifier for the feedback configuration"),
+  completionTimeInSeconds: z11.number().int().min(0).describe("Time taken to complete the feedback in seconds"),
+  userAction: userActionSchema.describe("Action performed by the user"),
+  responseLanguageCode: z11.string().length(2).describe("Language code for the response (e.g., 'en', 'es')")
+}).describe("Configuration information for the feedback form");
+var questionResponseSchema = z11.object({
+  questionId: z11.string().uuid().describe("Unique identifier for the question"),
+  answer: AnswerSchema.describe("The answer provided for this question"),
+  type: z11.string().describe("Type of the question (e.g., 'rating', 'single_choice')")
+}).describe("Response to a specific question in the feedback form");
+var responseSchema = z11.object({
+  questions: z11.array(questionResponseSchema).min(1).describe("Array of question responses")
+}).describe("User responses to feedback questions");
+var matchedTriggerPropertiesSchema = z11.object({
+  customEventName: z11.string().nullable().describe("Custom event name that triggered the feedback"),
+  currentPath: z11.string().describe("Current page path where feedback was triggered"),
+  eventType: z11.string().describe("Type of event that triggered the feedback")
+}).passthrough().describe("Properties of the trigger that matched for this feedback");
+var baseSubmitFeedbackSchema = z11.object({
+  formConfig: formConfigSchema.describe("Form configuration information"),
+  deviceInfo: deviceInfoSchema.describe("Device information"),
+  sessionInfo: sessionInfoSchema.describe("Session information"),
+  userInfo: userInfoSchema.optional().describe("User information (optional)"),
+  matchedTriggerProperties: matchedTriggerPropertiesSchema.describe(
+    "Properties of the matched trigger"
+  )
+}).describe("Base submit feedback request schema");
+var viewFeedbackSchema = baseSubmitFeedbackSchema.extend({
+  formConfig: formConfigSchema.extend({
+    userAction: z11.literal("V").describe("Action performed by the user (view)")
+  })
+}).strict().describe("View feedback request schema (no response required)");
+var submitFeedbackSchema = baseSubmitFeedbackSchema.extend({
+  formConfig: formConfigSchema.extend({
+    userAction: z11.literal("S").describe("Action performed by the user (submit)")
+  }),
+  response: responseSchema.describe("User responses (required for submit)")
+}).strict().describe("Submit feedback request schema (response required)");
+var feedbackRequestSchema = z11.union([
+  viewFeedbackSchema,
+  submitFeedbackSchema
+]).describe("Union schema for both view and submit feedback requests");
+
+// src/schemas/api/fetch-feedback-schema.ts
+import { z as z12 } from "zod";
+var feedbackConfigurationItemSchema = z12.object({
+  feedbackConfigurationId: z12.string().uuid().describe("Unique identifier for the feedback configuration"),
+  feedbackTitle: z12.string().describe("Title of the feedback configuration"),
+  duration: durationSchema.describe("Active duration for this feedback configuration"),
+  triggerProperties: audienceTriggerPropertiesSchema.describe("Trigger properties including auto/manual settings and audience segments"),
+  appearanceProperties: z12.object({
+    themes: z12.object({
+      light: z12.object({
+        brandColor: z12.string().describe("Brand color for light theme"),
+        overlayColor: z12.string().describe("Overlay color for light theme"),
+        textColor: z12.string().describe("Text color for light theme"),
+        backgroundColor: z12.string().describe("Background color for light theme")
+      }).describe("Light theme colors"),
+      dark: z12.object({
+        brandColor: z12.string().describe("Brand color for dark theme"),
+        overlayColor: z12.string().describe("Overlay color for dark theme"),
+        textColor: z12.string().describe("Text color for dark theme"),
+        backgroundColor: z12.string().describe("Background color for dark theme")
+      }).describe("Dark theme colors")
+    }).nullable().optional().describe("Theme configuration (optional)"),
+    featureSettings: z12.object({
+      darkOverlay: z12.boolean().describe("Whether to show dark overlay"),
+      closeButton: z12.boolean().describe("Whether to show close button"),
+      progressBar: z12.boolean().describe("Whether to show progress bar"),
+      showBranding: z12.boolean().describe("Whether to show branding"),
+      customPosition: z12.boolean().describe("Whether custom position is enabled"),
+      customIconPosition: z12.boolean().describe("Whether custom icon position is enabled"),
+      customCss: z12.string().nullable().optional().describe("Custom CSS link (optional)")
+    }).describe("Feature settings for the feedback form"),
+    selectedIconPosition: z12.string().describe("Selected position for the feedback icon"),
+    selectedPosition: z12.string().describe("Selected position for the feedback form")
+  }).describe("Appearance properties for the feedback form")
+}).describe("Individual feedback configuration item in the list");
+var fetchFormConfigSchema = z12.object({
+  feedbackConfigurationId: z12.string().uuid().describe("Unique identifier for the feedback configuration"),
+  responseLanguageCode: z12.string().length(2).describe("Language code for the response (e.g., 'en', 'es')")
+}).describe("Form configuration for fetching feedback details");
+var fetchConfigurationListSchema = z12.object({
+  deviceInfo: deviceInfoSchema.describe("Device information"),
+  sessionInfo: sessionInfoSchema.describe("Session information"),
+  userInfo: userInfoSchema.optional().describe("User information (optional)")
+}).strict().describe("Request schema for fetching available feedback configurations");
+var fetchFeedbackDetailsSchema = z12.object({
+  formConfig: fetchFormConfigSchema.describe("Form configuration for the specific feedback"),
+  deviceInfo: deviceInfoSchema.describe("Device information"),
+  sessionInfo: sessionInfoSchema.describe("Session information"),
+  userInfo: userInfoSchema.optional().describe("User information (optional)")
+}).strict().describe("Request schema for fetching specific feedback form details");
+var formConfigurationResponseSchema = z12.object({
+  formTitle: z12.string().describe("Title of the feedback form"),
+  formDescription: z12.string().describe("Description of the feedback form")
+}).describe("Form configuration response with title and description");
+var questionnaireFieldsResponseSchema = z12.object({
+  questions: z12.record(z12.string(), combinedQuestionSchema).describe("Collection of questions keyed by their string identifiers"),
+  sections: z12.array(sectionSchema).describe("Array of sections that organize questions into logical groups"),
+  translations: z12.record(z12.string(), z12.any()).describe("Translations object (can be empty or contain language-specific translations)"),
+  selectedLanguages: LanguagesSchema.describe("Array of languages selected for this questionnaire")
+}).describe("Questionnaire fields response including questions, sections, translations, and selected languages");
+var fetchFeedbackDetailsResponseSchema = z12.object({
+  feedbackConfigurationId: z12.string().uuid().describe("Unique identifier for the feedback configuration"),
+  feedbackIdentifier: z12.string().uuid().describe("Unique identifier for this specific feedback instance"),
+  formConfiguration: formConfigurationResponseSchema.describe("Form configuration with title and description"),
+  questionnaireFields: questionnaireFieldsResponseSchema.describe("Questionnaire structure including questions, sections, translations, and languages"),
+  otherConfigurationProperties: otherConfigurationPropertiesSchema.describe("Other configuration properties using existing schema"),
+  welcomeScreenProperties: welcomeScreenPropertiesSchema.describe("Welcome screen properties using existing schema"),
+  endScreenProperties: endScreenPropertiesSchema.describe("End screen properties using existing schema")
+}).strict().describe("Complete response schema for fetchFeedbackDetails API using existing field schemas");
+var fetchConfigurationListResponseSchema = z12.object({
+  masterProperties: masterPropertiesSchema.describe("Master properties for global survey settings"),
+  feedbackConfiguration: z12.array(feedbackConfigurationItemSchema).describe("Array of available feedback configurations")
+}).strict().describe("Response schema for fetchConfigurationList API");
+
+// src/index.ts
+import { z as z13 } from "zod";
 export {
   AnswerSchema,
   ChoiceAnswerSchema,
   ChoiceOrderOptions,
   ContinuousSumAnswerSchema,
+  DeviceThemes,
   DismissBehaviors,
   EndFieldsTranslationSchema,
   EndScreenFieldsSchema,
@@ -1020,6 +1188,7 @@ export {
   TextAnswerSchema,
   ThemeModes,
   TranslationProvider,
+  UserActions,
   ValidationRuleTypes,
   VisibilityConditionOperators,
   WelcomeFieldsTranslationSchema,
@@ -1030,6 +1199,7 @@ export {
   appearancePropertiesSchema,
   audienceSegmentSchema,
   audienceTriggerPropertiesSchema,
+  baseSubmitFeedbackSchema,
   categorySpecificFiltersSchema,
   choiceOrderOptionSchema,
   combinedQuestionSchema,
@@ -1039,18 +1209,32 @@ export {
   createTranslationProvider,
   customEventFieldOperatorSchema,
   customEventFieldSchema,
+  deviceInfoSchema,
+  deviceSessionInfoSchema,
+  deviceThemeSchema,
   dismissBehaviorSchema,
+  durationSchema,
   endScreenPropertiesSchema,
   externalPublishingPropertiesSchema,
   featureSettingsSchema,
+  feedbackConfigurationItemSchema,
   feedbackConfigurationSchema,
+  feedbackRequestSchema,
+  fetchConfigurationListResponseSchema,
+  fetchConfigurationListSchema,
+  fetchFeedbackDetailsResponseSchema,
+  fetchFeedbackDetailsSchema,
+  fetchFormConfigSchema,
   filterConditionSchema,
+  formConfigSchema,
+  formConfigurationResponseSchema,
   formPropertiesSchema,
   frequencyAndSchedulingPropertiesSchema,
   languageTranslationsSchema,
   longAnswerQuestionSchema,
   longAnswerTranslationsSchema,
   masterPropertiesSchema,
+  matchedTriggerPropertiesSchema,
   multipleChoiceDisplayStyleSchema,
   multipleChoiceMultipleDisplayStyleSchema,
   multipleChoiceMultipleQuestionSchema,
@@ -1066,19 +1250,24 @@ export {
   publicationStatusSchema,
   queryOutputSchema,
   questionOptionSchema,
+  questionResponseSchema,
   questionSchema,
   questionStatusSchema,
   questionTranslationsSchema,
   questionTypeSchema,
+  questionnaireFieldsResponseSchema,
   ratingDisplayStyleSchema,
   ratingQuestionSchema,
   ratingRepresentationSizeSchema,
   ratingTranslationsSchema,
   recurringUnitSchema,
+  responseSchema,
   sectionSchema,
+  sessionInfoSchema,
   shortAnswerQuestionSchema,
   shortAnswerTranslationsSchema,
   singleChoiceTranslationsSchema,
+  submitFeedbackSchema,
   surveyTypeSchema,
   themeColorsSchema,
   themeConfigurationSchema,
@@ -1087,12 +1276,16 @@ export {
   translationEntrySchema,
   translationsSchema,
   triggerActionSchema,
+  userActionSchema,
+  userInfoSchema,
+  userPropertiesSchema,
   validationRuleSchema,
   validationRuleTypeSchema,
+  viewFeedbackSchema,
   visibilityConditionSchema,
   welcomeScreenPropertiesSchema,
   whoSchema,
   yesNoSchema,
-  z10 as z
+  z13 as z
 };
 //# sourceMappingURL=index.js.map