@encatch/schema 0.1.16 → 0.1.19

package/dist/esm/index.js

@@ -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) {
@@ -550,124 +551,146 @@ var PublicationStatuses = {
   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";
 
 // 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({
+var translationEntrySchema = z4.string().min(1).describe("Translated text content");
+var ratingQuestionTranslationSchema = z4.object({
+  type: z4.literal("rating").describe("Question type identifier"),
   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({
+var singleChoiceQuestionTranslationSchema = z4.object({
+  type: z4.literal("single_choice").describe("Question type identifier"),
   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")
+  placeholder: translationEntrySchema.optional().describe("Input placeholder translation")
+}).catchall(translationEntrySchema).refine((data) => {
+  const additionalKeys = Object.keys(data).filter(
+    (key) => !["type", "title", "description", "errorMessage", "placeholder"].includes(key)
+  );
+  return additionalKeys.every((key) => /^option\..+\.(label|value)$/.test(key));
+}, {
+  message: "Additional keys must follow the pattern 'option.{id}.{label|value}'"
 }).describe("Translation schema for single choice questions");
-var multipleChoiceTranslationsSchema = z4.object({
+var multipleChoiceQuestionTranslationSchema = z4.object({
+  type: z4.literal("multiple_choice_multiple").describe("Question type identifier"),
   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")
+  placeholder: translationEntrySchema.optional().describe("Input placeholder translation")
+}).catchall(translationEntrySchema).refine((data) => {
+  const additionalKeys = Object.keys(data).filter(
+    (key) => !["type", "title", "description", "errorMessage", "placeholder"].includes(key)
+  );
+  return additionalKeys.every((key) => /^option\..+\.(label|value)$/.test(key));
+}, {
+  message: "Additional keys must follow the pattern 'option.{id}.{label|value}'"
 }).describe("Translation schema for multiple choice questions");
-var npsTranslationsSchema = z4.object({
+var npsQuestionTranslationSchema = z4.object({
+  type: z4.literal("nps").describe("Question type identifier"),
   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)")
+  maxLabel: translationEntrySchema.optional().describe("Maximum NPS label (10) translation")
+}).catchall(translationEntrySchema).refine((data) => {
+  const additionalKeys = Object.keys(data).filter(
+    (key) => !["type", "title", "description", "errorMessage", "minLabel", "maxLabel"].includes(key)
+  );
+  return additionalKeys.every((key) => /^scaleLabel\.\d+$/.test(key));
+}, {
+  message: "Additional keys must follow the pattern 'scaleLabel.{number}'"
 }).describe("Translation schema for NPS questions");
-var shortAnswerTranslationsSchema = z4.object({
+var shortAnswerQuestionTranslationSchema = z4.object({
+  type: z4.literal("short_answer").describe("Question type identifier"),
   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({
+var longAnswerQuestionTranslationSchema = z4.object({
+  type: z4.literal("long_text").describe("Question type identifier"),
   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({
+var nestedSelectionQuestionTranslationSchema = z4.object({
+  type: z4.literal("nested_selection").describe("Question type identifier"),
   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")
+  placeholder: translationEntrySchema.optional().describe("Dropdown placeholder translation")
+}).catchall(translationEntrySchema).refine((data) => {
+  const additionalKeys = Object.keys(data).filter(
+    (key) => !["type", "title", "description", "errorMessage", "placeholder"].includes(key)
+  );
+  return additionalKeys.every((key) => /^nestedOption\..+\.(label|hint)$/.test(key));
+}, {
+  message: "Additional keys must follow the pattern 'nestedOption.{id}.{label|hint}'"
 }).describe("Translation schema for nested selection questions");
-var annotationTranslationsSchema = z4.object({
+var annotationQuestionTranslationSchema = z4.object({
+  type: z4.literal("annotation").describe("Question type identifier"),
   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 questionTranslationSchema = z4.union([
+  ratingQuestionTranslationSchema,
+  singleChoiceQuestionTranslationSchema,
+  multipleChoiceQuestionTranslationSchema,
+  npsQuestionTranslationSchema,
+  shortAnswerQuestionTranslationSchema,
+  longAnswerQuestionTranslationSchema,
+  nestedSelectionQuestionTranslationSchema,
+  annotationQuestionTranslationSchema
+]).describe("Union of all question type translation schemas");
+var languageCodeSchema = z4.string().min(2).max(10).describe("Language code (e.g., 'en', 'es', 'hi')");
+var questionTranslationsByLanguageSchema = z4.record(languageCodeSchema, questionTranslationSchema).describe("Question translations keyed by language code");
+var questionCentricTranslationsSchema = z4.record(z4.string().uuid(), questionTranslationsByLanguageSchema).describe("Question-centric translations keyed by question ID, then by language code");
 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");
+  questions: questionCentricTranslationsSchema.describe("Question-centric translations")
+}).describe("Complete question-centric translation schema");
 var _TranslationProvider = class _TranslationProvider {
   constructor(translations) {
     this.translations = translations;
@@ -676,48 +699,59 @@ var _TranslationProvider = class _TranslationProvider {
    * 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;
+    const questionTranslations = this.translations.questions[questionId];
+    if (!questionTranslations) return null;
+    let translation = questionTranslations[languageCode];
+    if (!translation) {
+      translation = questionTranslations[this.translations.defaultLanguage];
     }
-    return languageData.questions[questionId] || null;
+    return translation || null;
   }
   /**
-   * Get a specific translation text
+   * Get a specific translation text by field path
    */
-  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;
+  getTranslationText(questionId, languageCode, fieldPath) {
+    const questionTranslation = this.getQuestionTranslations(questionId, languageCode);
+    if (!questionTranslation) return null;
+    if (fieldPath in questionTranslation) {
+      const value = questionTranslation[fieldPath];
+      return typeof value === "string" ? value : null;
     }
     return null;
   }
   /**
-   * Get all available languages
+   * Get all available languages for a specific question
+   */
+  getQuestionLanguages(questionId) {
+    const questionTranslations = this.translations.questions[questionId];
+    if (!questionTranslations) return [];
+    return Object.keys(questionTranslations);
+  }
+  /**
+   * Get all available languages across all questions
    */
   getAvailableLanguages() {
-    return this.translations.languages.map((lang) => lang.languageCode);
+    const allLanguages = /* @__PURE__ */ new Set();
+    Object.values(this.translations.questions).forEach((questionTranslations) => {
+      Object.keys(questionTranslations).forEach((langCode) => {
+        allLanguages.add(langCode);
+      });
+    });
+    return Array.from(allLanguages);
   }
   /**
-   * Check if a language is supported
+   * Check if a language is supported for a specific question
+   */
+  isLanguageSupportedForQuestion(questionId, languageCode) {
+    const questionTranslations = this.translations.questions[questionId];
+    if (!questionTranslations) return false;
+    return languageCode in questionTranslations;
+  }
+  /**
+   * Check if a language is supported across all questions
    */
   isLanguageSupported(languageCode) {
-    return this.translations.languages.some((lang) => lang.languageCode === languageCode);
+    return this.getAvailableLanguages().includes(languageCode);
   }
   /**
    * Get the default language
@@ -725,6 +759,20 @@ var _TranslationProvider = class _TranslationProvider {
   getDefaultLanguage() {
     return this.translations.defaultLanguage;
   }
+  /**
+   * Get all questions that have translations
+   */
+  getQuestionIds() {
+    return Object.keys(this.translations.questions);
+  }
+  /**
+   * Get question type for a specific question
+   */
+  getQuestionType(questionId, languageCode) {
+    const langCode = languageCode || this.translations.defaultLanguage;
+    const translation = this.getQuestionTranslations(questionId, langCode);
+    return translation?.type || null;
+  }
 };
 __name(_TranslationProvider, "TranslationProvider");
 var TranslationProvider = _TranslationProvider;
@@ -989,13 +1037,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,16 +1231,18 @@ export {
   TextAnswerSchema,
   ThemeModes,
   TranslationProvider,
+  UserActions,
   ValidationRuleTypes,
   VisibilityConditionOperators,
   WelcomeFieldsTranslationSchema,
   WelcomeScreenFieldsSchema,
   YesNoValues,
   annotationQuestionSchema,
-  annotationTranslationsSchema,
+  annotationQuestionTranslationSchema,
   appearancePropertiesSchema,
   audienceSegmentSchema,
   audienceTriggerPropertiesSchema,
+  baseSubmitFeedbackSchema,
   categorySpecificFiltersSchema,
   choiceOrderOptionSchema,
   combinedQuestionSchema,
@@ -1039,46 +1252,65 @@ 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,
+  longAnswerQuestionTranslationSchema,
   masterPropertiesSchema,
+  matchedTriggerPropertiesSchema,
   multipleChoiceDisplayStyleSchema,
   multipleChoiceMultipleDisplayStyleSchema,
   multipleChoiceMultipleQuestionSchema,
+  multipleChoiceQuestionTranslationSchema,
   multipleChoiceSingleQuestionSchema,
-  multipleChoiceTranslationsSchema,
   nestedDropdownQuestionSchema,
   nestedOptionSchema,
-  nestedSelectionTranslationsSchema,
+  nestedSelectionQuestionTranslationSchema,
   npsQuestionSchema,
-  npsTranslationsSchema,
+  npsQuestionTranslationSchema,
   otherConfigurationPropertiesSchema,
   positionSchema,
   publicationStatusSchema,
   queryOutputSchema,
+  questionCentricTranslationsSchema,
   questionOptionSchema,
+  questionResponseSchema,
   questionSchema,
   questionStatusSchema,
-  questionTranslationsSchema,
+  questionTranslationSchema,
   questionTypeSchema,
+  questionnaireFieldsResponseSchema,
   ratingDisplayStyleSchema,
   ratingQuestionSchema,
+  ratingQuestionTranslationSchema,
   ratingRepresentationSizeSchema,
-  ratingTranslationsSchema,
   recurringUnitSchema,
+  responseSchema,
   sectionSchema,
+  sessionInfoSchema,
   shortAnswerQuestionSchema,
-  shortAnswerTranslationsSchema,
-  singleChoiceTranslationsSchema,
+  shortAnswerQuestionTranslationSchema,
+  singleChoiceQuestionTranslationSchema,
+  submitFeedbackSchema,
   surveyTypeSchema,
   themeColorsSchema,
   themeConfigurationSchema,
@@ -1087,12 +1319,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