package medalliaapi

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1
 * User agent: apibuilder app.apibuilder.io/edsancha/medallia-api/0.0.1/go_1_5_client
 */

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"strconv"
	"strings"
)

const BaseUrl = "https://api-us.kampyle.com/api/v1"
const UserAgent = "apibuilder app.apibuilder.io/edsancha/medallia-api/0.0.1/go_1_5_client"
const Version = "0.0.1"
const VersionMajor = 0

type Client struct {
	HttpClient *http.Client
	Username   string
	Password   string
	BaseUrl    string
	Headers    http.Header
}

type ClientRequestBody struct {
	contentType string
	bytes       io.Reader
}

type CompareString string

const (
	CompareStringGreaterThan CompareString  = "greaterThan"
	CompareStringEquals                     = "equals"
	CompareStringSmallerThan                = "smallerThan"
	CompareStringUNDEFINED                  = "UNDEFINED"
)

func CompareStringFromString(value string) CompareString {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "greaterthan":
		return CompareStringGreaterThan
	case "equals":
		return CompareStringEquals
	case "smallerthan":
		return CompareStringSmallerThan
	default:
		return CompareStringUNDEFINED
	}
}

type FormType string

const (
	FormTypeMobileInvitation FormType  = "mobileInvitation"
	FormTypeCode                       = "code"
	FormTypeUNDEFINED                  = "UNDEFINED"
)

func FormTypeFromString(value string) FormType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "mobileinvitation":
		return FormTypeMobileInvitation
	case "code":
		return FormTypeCode
	default:
		return FormTypeUNDEFINED
	}
}

type RatingViewType string

const (
	RatingViewTypeSlide RatingViewType  = "slide"
	RatingViewTypeNumbersSquare         = "numbersSquare"
	RatingViewTypeGradingSlider         = "gradingSlider"
	RatingViewTypeGradingDropdown       = "gradingDropdown"
	RatingViewTypeStars                 = "stars"
	RatingViewTypeEmoticons             = "emoticons"
	RatingViewTypeNumbers               = "numbers"
	RatingViewTypeSmilies               = "smilies"
	RatingViewTypeBars                  = "bars"
	RatingViewTypeUNDEFINED             = "UNDEFINED"
)

func RatingViewTypeFromString(value string) RatingViewType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "slide":
		return RatingViewTypeSlide
	case "numberssquare":
		return RatingViewTypeNumbersSquare
	case "gradingslider":
		return RatingViewTypeGradingSlider
	case "gradingdropdown":
		return RatingViewTypeGradingDropdown
	case "stars":
		return RatingViewTypeStars
	case "emoticons":
		return RatingViewTypeEmoticons
	case "numbers":
		return RatingViewTypeNumbers
	case "smilies":
		return RatingViewTypeSmilies
	case "bars":
		return RatingViewTypeBars
	default:
		return RatingViewTypeUNDEFINED
	}
}

/**
 * JWT Access Token to be used to access the APIe
 */
type AccessTokenWrapper struct {
	AccessToken string `json:"accessToken"`
}

func AccessTokenWrapperFromMap(data interface{}) AccessTokenWrapper {
	b, err := json.Marshal(data)
	if err == nil {
		return AccessTokenWrapperFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func AccessTokenWrapperFromJson(bytes io.Reader) AccessTokenWrapper {
	var accessTokenWrapper AccessTokenWrapper
	json.NewDecoder(bytes).Decode(&accessTokenWrapper)
	return accessTokenWrapper
}

type ComponentCheckbox struct {
	Index       int32    `json:"index"`
	Id          int32    `json:"id"`
	UniqueName  string   `json:"unique_name"`
	Required    string   `json:"required"`
	Label       string   `json:"label"`
	Options     []string `json:"options"`
	Description string   `json:"description,omitempty"`
}

func ComponentCheckboxFromMap(data interface{}) ComponentCheckbox {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentCheckboxFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentCheckboxFromJson(bytes io.Reader) ComponentCheckbox {
	var componentCheckbox ComponentCheckbox
	json.NewDecoder(bytes).Decode(&componentCheckbox)
	return componentCheckbox
}

type ComponentDropdown struct {
	Index       int32    `json:"index"`
	Id          int32    `json:"id"`
	UniqueName  string   `json:"unique_name"`
	Required    string   `json:"required"`
	Placeholder string   `json:"placeholder"`
	Label       string   `json:"label"`
	Options     []string `json:"options"`
	Description string   `json:"description,omitempty"`
}

func ComponentDropdownFromMap(data interface{}) ComponentDropdown {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentDropdownFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentDropdownFromJson(bytes io.Reader) ComponentDropdown {
	var componentDropdown ComponentDropdown
	json.NewDecoder(bytes).Decode(&componentDropdown)
	return componentDropdown
}

type ComponentGrading struct {
	Index          int32          `json:"index"`
	Id             int32          `json:"id"`
	UniqueName     string         `json:"unique_name"`
	Required       string         `json:"required"`
	Label          string         `json:"label"`
	RatingViewType RatingViewType `json:"ratingViewType"`
	Description    string         `json:"description,omitempty"`
}

func ComponentGradingFromMap(data interface{}) ComponentGrading {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentGradingFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentGradingFromJson(bytes io.Reader) ComponentGrading {
	var componentGrading ComponentGrading
	json.NewDecoder(bytes).Decode(&componentGrading)
	return componentGrading
}

type ComponentGrading0to10 struct {
	Index          int32          `json:"index"`
	Id             int32          `json:"id"`
	UniqueName     string         `json:"unique_name"`
	Required       string         `json:"required"`
	Label          string         `json:"label"`
	RatingViewType RatingViewType `json:"ratingViewType"`
	Description    string         `json:"description,omitempty"`
}

func ComponentGrading0to10FromMap(data interface{}) ComponentGrading0to10 {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentGrading0to10FromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentGrading0to10FromJson(bytes io.Reader) ComponentGrading0to10 {
	var componentGrading0to10 ComponentGrading0to10
	json.NewDecoder(bytes).Decode(&componentGrading0to10)
	return componentGrading0to10
}

type ComponentGrading1to10 struct {
	Index          int32          `json:"index"`
	Id             int32          `json:"id"`
	UniqueName     string         `json:"unique_name"`
	Required       string         `json:"required"`
	Label          string         `json:"label"`
	RatingViewType RatingViewType `json:"ratingViewType"`
	Description    string         `json:"description,omitempty"`
}

func ComponentGrading1to10FromMap(data interface{}) ComponentGrading1to10 {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentGrading1to10FromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentGrading1to10FromJson(bytes io.Reader) ComponentGrading1to10 {
	var componentGrading1to10 ComponentGrading1to10
	json.NewDecoder(bytes).Decode(&componentGrading1to10)
	return componentGrading1to10
}

type ComponentImage struct {
	Index            int32  `json:"index"`
	Id               int32  `json:"id"`
	UniqueName       string `json:"unique_name"`
	ImageObject      Image  `json:"imageObject,omitempty"`
	UploadedResource Image  `json:"uploadedResource,omitempty"`
}

func ComponentImageFromMap(data interface{}) ComponentImage {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentImageFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentImageFromJson(bytes io.Reader) ComponentImage {
	var componentImage ComponentImage
	json.NewDecoder(bytes).Decode(&componentImage)
	return componentImage
}

type ComponentLabel struct {
	Index        int32  `json:"index"`
	Id           int32  `json:"id"`
	UniqueName   string `json:"unique_name"`
	LabelContent string `json:"labelContent,omitempty"`
	NumOfLines   int32  `json:"num_of_lines"`
}

func ComponentLabelFromMap(data interface{}) ComponentLabel {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentLabelFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentLabelFromJson(bytes io.Reader) ComponentLabel {
	var componentLabel ComponentLabel
	json.NewDecoder(bytes).Decode(&componentLabel)
	return componentLabel
}

type ComponentNps struct {
	Index          int32          `json:"index"`
	Id             int32          `json:"id"`
	UniqueName     string         `json:"unique_name"`
	Required       string         `json:"required"`
	Label          string         `json:"label"`
	Description    string         `json:"description,omitempty"`
	RatingViewType RatingViewType `json:"ratingViewType"`
}

func ComponentNpsFromMap(data interface{}) ComponentNps {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentNpsFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentNpsFromJson(bytes io.Reader) ComponentNps {
	var componentNps ComponentNps
	json.NewDecoder(bytes).Decode(&componentNps)
	return componentNps
}

type ComponentRadioSelector struct {
	Index       int32    `json:"index"`
	Id          int32    `json:"id"`
	UniqueName  string   `json:"unique_name"`
	Required    string   `json:"required"`
	Label       string   `json:"label"`
	Options     []string `json:"options"`
	Description string   `json:"description,omitempty"`
}

func ComponentRadioSelectorFromMap(data interface{}) ComponentRadioSelector {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentRadioSelectorFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentRadioSelectorFromJson(bytes io.Reader) ComponentRadioSelector {
	var componentRadioSelector ComponentRadioSelector
	json.NewDecoder(bytes).Decode(&componentRadioSelector)
	return componentRadioSelector
}

type ComponentTextArea struct {
	Index       int32  `json:"index"`
	Id          int32  `json:"id"`
	UniqueName  string `json:"unique_name"`
	Required    string `json:"required"`
	Placeholder string `json:"placeholder"`
	Label       string `json:"label"`
	NumOfLines  int32  `json:"num_of_lines"`
	Description string `json:"description,omitempty"`
}

func ComponentTextAreaFromMap(data interface{}) ComponentTextArea {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentTextAreaFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentTextAreaFromJson(bytes io.Reader) ComponentTextArea {
	var componentTextArea ComponentTextArea
	json.NewDecoder(bytes).Decode(&componentTextArea)
	return componentTextArea
}

type ComponentTextInput struct {
	Index       int32  `json:"index"`
	Id          int32  `json:"id"`
	UniqueName  string `json:"unique_name"`
	Required    string `json:"required"`
	Placeholder string `json:"placeholder"`
	Label       string `json:"label"`
	MaxChars    int32  `json:"max_chars"`
	Description string `json:"description,omitempty"`
}

func ComponentTextInputFromMap(data interface{}) ComponentTextInput {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentTextInputFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentTextInputFromJson(bytes io.Reader) ComponentTextInput {
	var componentTextInput ComponentTextInput
	json.NewDecoder(bytes).Decode(&componentTextInput)
	return componentTextInput
}

/**
 * Configuration main object, including forms
 */
type Configuration struct {
	PropertyId        int32  `json:"propertyId"`
	FeedbackSubmitUrl string `json:"feedbackSubmitUrl"`
	Forms             []Form `json:"forms"`
}

func ConfigurationFromMap(data interface{}) Configuration {
	b, err := json.Marshal(data)
	if err == nil {
		return ConfigurationFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ConfigurationFromJson(bytes io.Reader) Configuration {
	var configuration Configuration
	json.NewDecoder(bytes).Decode(&configuration)
	return configuration
}

type DynamicData struct {
	Index       int32    `json:"index"`
	Id          int32    `json:"id"`
	Required    string   `json:"required"`
	Component   string   `json:"component"`
	UniqueName  string   `json:"unique_name"`
	Placeholder string   `json:"placeholder"`
	Label       string   `json:"label"`
	Description string   `json:"description,omitempty"`
	Options     []string `json:"options,omitempty"`
	ImageObject Image    `json:"imageObject,omitempty"`
}

func DynamicDataFromMap(data interface{}) DynamicData {
	b, err := json.Marshal(data)
	if err == nil {
		return DynamicDataFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func DynamicDataFromJson(bytes io.Reader) DynamicData {
	var dynamicData DynamicData
	json.NewDecoder(bytes).Decode(&dynamicData)
	return dynamicData
}

/**
 * Feedback main object with survey's results
 */
type Feedback struct {
	FormId      int32        `json:"formId"`
	DynamicData FeedbackData `json:"dynamicData"`
}

func FeedbackFromMap(data interface{}) Feedback {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackFromJson(bytes io.Reader) Feedback {
	var feedback Feedback
	json.NewDecoder(bytes).Decode(&feedback)
	return feedback
}

type FeedbackCheckbox struct {
	Index      int32   `json:"index"`
	Id         int32   `json:"id"`
	UniqueName string  `json:"unique_name"`
	Value      []int32 `json:"value"`
	Type       string  `json:"type"`
}

func FeedbackCheckboxFromMap(data interface{}) FeedbackCheckbox {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackCheckboxFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackCheckboxFromJson(bytes io.Reader) FeedbackCheckbox {
	var feedbackCheckbox FeedbackCheckbox
	json.NewDecoder(bytes).Decode(&feedbackCheckbox)
	return feedbackCheckbox
}

/**
 * Object that will hold the form pages and custom parameters.
 */
type FeedbackData struct {
	CustomParams interface{}    `json:"customParams,omitempty"`
	Pages        []FeedbackPage `json:"pages"`
}

func FeedbackDataFromMap(data interface{}) FeedbackData {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackDataFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackDataFromJson(bytes io.Reader) FeedbackData {
	var feedbackData FeedbackData
	json.NewDecoder(bytes).Decode(&feedbackData)
	return feedbackData
}

type FeedbackDropdown struct {
	Index      int32  `json:"index"`
	Id         int32  `json:"id"`
	UniqueName string `json:"unique_name"`
	Value      int32  `json:"value"`
	Type       string `json:"type"`
}

func FeedbackDropdownFromMap(data interface{}) FeedbackDropdown {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackDropdownFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackDropdownFromJson(bytes io.Reader) FeedbackDropdown {
	var feedbackDropdown FeedbackDropdown
	json.NewDecoder(bytes).Decode(&feedbackDropdown)
	return feedbackDropdown
}

type FeedbackGrading struct {
	Index      int32  `json:"index"`
	Id         int32  `json:"id"`
	UniqueName string `json:"unique_name"`
	Value      int32  `json:"value"`
	Type       string `json:"type"`
}

func FeedbackGradingFromMap(data interface{}) FeedbackGrading {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackGradingFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackGradingFromJson(bytes io.Reader) FeedbackGrading {
	var feedbackGrading FeedbackGrading
	json.NewDecoder(bytes).Decode(&feedbackGrading)
	return feedbackGrading
}

type FeedbackGrading0to10 struct {
	Index      int32  `json:"index"`
	Id         int32  `json:"id"`
	UniqueName string `json:"unique_name"`
	Value      int32  `json:"value"`
	Type       string `json:"type"`
}

func FeedbackGrading0to10FromMap(data interface{}) FeedbackGrading0to10 {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackGrading0to10FromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackGrading0to10FromJson(bytes io.Reader) FeedbackGrading0to10 {
	var feedbackGrading0to10 FeedbackGrading0to10
	json.NewDecoder(bytes).Decode(&feedbackGrading0to10)
	return feedbackGrading0to10
}

type FeedbackGrading1to10 struct {
	Index      int32  `json:"index"`
	Id         int32  `json:"id"`
	UniqueName string `json:"unique_name"`
	Value      int32  `json:"value"`
	Type       string `json:"type"`
}

func FeedbackGrading1to10FromMap(data interface{}) FeedbackGrading1to10 {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackGrading1to10FromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackGrading1to10FromJson(bytes io.Reader) FeedbackGrading1to10 {
	var feedbackGrading1to10 FeedbackGrading1to10
	json.NewDecoder(bytes).Decode(&feedbackGrading1to10)
	return feedbackGrading1to10
}

type FeedbackNps struct {
	Index      int32  `json:"index"`
	Id         int32  `json:"id"`
	UniqueName string `json:"unique_name"`
	Value      int32  `json:"value"`
	Type       string `json:"type"`
}

func FeedbackNpsFromMap(data interface{}) FeedbackNps {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackNpsFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackNpsFromJson(bytes io.Reader) FeedbackNps {
	var feedbackNps FeedbackNps
	json.NewDecoder(bytes).Decode(&feedbackNps)
	return feedbackNps
}

/**
 * Object that will hold the form page
 */
type FeedbackPage struct {
	Components []FeedbackUnion `json:"components"`
}

func FeedbackPageFromMap(data interface{}) FeedbackPage {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackPageFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackPageFromJson(bytes io.Reader) FeedbackPage {
	var feedbackPage FeedbackPage
	json.NewDecoder(bytes).Decode(&feedbackPage)
	return feedbackPage
}

type FeedbackRadioSelector struct {
	Index      int32  `json:"index"`
	Id         int32  `json:"id"`
	UniqueName string `json:"unique_name"`
	Value      int32  `json:"value"`
	Type       string `json:"type"`
}

func FeedbackRadioSelectorFromMap(data interface{}) FeedbackRadioSelector {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackRadioSelectorFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackRadioSelectorFromJson(bytes io.Reader) FeedbackRadioSelector {
	var feedbackRadioSelector FeedbackRadioSelector
	json.NewDecoder(bytes).Decode(&feedbackRadioSelector)
	return feedbackRadioSelector
}

type FeedbackTextArea struct {
	Index      int32  `json:"index"`
	Id         int32  `json:"id"`
	UniqueName string `json:"unique_name"`
	Value      string `json:"value"`
	Type       string `json:"type"`
}

func FeedbackTextAreaFromMap(data interface{}) FeedbackTextArea {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackTextAreaFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackTextAreaFromJson(bytes io.Reader) FeedbackTextArea {
	var feedbackTextArea FeedbackTextArea
	json.NewDecoder(bytes).Decode(&feedbackTextArea)
	return feedbackTextArea
}

type FeedbackTextInput struct {
	Index      int32  `json:"index"`
	Id         int32  `json:"id"`
	UniqueName string `json:"unique_name"`
	Value      string `json:"value"`
	Type       string `json:"type"`
}

func FeedbackTextInputFromMap(data interface{}) FeedbackTextInput {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackTextInputFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackTextInputFromJson(bytes io.Reader) FeedbackTextInput {
	var feedbackTextInput FeedbackTextInput
	json.NewDecoder(bytes).Decode(&feedbackTextInput)
	return feedbackTextInput
}

type Form struct {
	FormId      int32       `json:"formId"`
	Name        string      `json:"name"`
	Title       string      `json:"title"`
	FormType    FormType    `json:"formType"`
	InviteData  InviteData  `json:"inviteData,omitempty"`
	TriggerData TriggerData `json:"triggerData,omitempty"`
	FormJson    FormJson    `json:"formJson"`
}

func FormFromMap(data interface{}) Form {
	b, err := json.Marshal(data)
	if err == nil {
		return FormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FormFromJson(bytes io.Reader) Form {
	var form Form
	json.NewDecoder(bytes).Decode(&form)
	return form
}

type FormJson struct {
	Pages []Page `json:"pages"`
}

func FormJsonFromMap(data interface{}) FormJson {
	b, err := json.Marshal(data)
	if err == nil {
		return FormJsonFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FormJsonFromJson(bytes io.Reader) FormJson {
	var formJson FormJson
	json.NewDecoder(bytes).Decode(&formJson)
	return formJson
}

type Image struct {
	Name string `json:"name"`
	Url  string `json:"url"`
}

func ImageFromMap(data interface{}) Image {
	b, err := json.Marshal(data)
	if err == nil {
		return ImageFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ImageFromJson(bytes io.Reader) Image {
	var image Image
	json.NewDecoder(bytes).Decode(&image)
	return image
}

type InviteData struct {
	InvitationHeadline string `json:"invitationHeadline"`
	InvitationText     string `json:"invitationText"`
	ProvideButtonText  string `json:"provideButtonText"`
	DeclineButtonText  string `json:"declineButtonText"`
	LaterButtonText    string `json:"laterButtonText"`
}

func InviteDataFromMap(data interface{}) InviteData {
	b, err := json.Marshal(data)
	if err == nil {
		return InviteDataFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func InviteDataFromJson(bytes io.Reader) InviteData {
	var inviteData InviteData
	json.NewDecoder(bytes).Decode(&inviteData)
	return inviteData
}

type NumberOfAppSession struct {
	Number        string        `json:"number"`
	CompareString CompareString `json:"compareString"`
}

func NumberOfAppSessionFromMap(data interface{}) NumberOfAppSession {
	b, err := json.Marshal(data)
	if err == nil {
		return NumberOfAppSessionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func NumberOfAppSessionFromJson(bytes io.Reader) NumberOfAppSession {
	var numberOfAppSession NumberOfAppSession
	json.NewDecoder(bytes).Decode(&numberOfAppSession)
	return numberOfAppSession
}

type NumberOfDays struct {
	Days string `json:"days"`
}

func NumberOfDaysFromMap(data interface{}) NumberOfDays {
	b, err := json.Marshal(data)
	if err == nil {
		return NumberOfDaysFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func NumberOfDaysFromJson(bytes io.Reader) NumberOfDays {
	var numberOfDays NumberOfDays
	json.NewDecoder(bytes).Decode(&numberOfDays)
	return numberOfDays
}

type Page struct {
	Name        string           `json:"name"`
	Index       int32            `json:"index"`
	DynamicData []ComponentUnion `json:"dynamicData"`
}

func PageFromMap(data interface{}) Page {
	b, err := json.Marshal(data)
	if err == nil {
		return PageFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PageFromJson(bytes io.Reader) Page {
	var page Page
	json.NewDecoder(bytes).Decode(&page)
	return page
}

type PercentageOfSessions struct {
	Prec string `json:"prec"`
}

func PercentageOfSessionsFromMap(data interface{}) PercentageOfSessions {
	b, err := json.Marshal(data)
	if err == nil {
		return PercentageOfSessionsFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PercentageOfSessionsFromJson(bytes io.Reader) PercentageOfSessions {
	var percentageOfSessions PercentageOfSessions
	json.NewDecoder(bytes).Decode(&percentageOfSessions)
	return percentageOfSessions
}

type TimeInForeground struct {
	Time          string        `json:"time"`
	CompareString CompareString `json:"compareString"`
}

func TimeInForegroundFromMap(data interface{}) TimeInForeground {
	b, err := json.Marshal(data)
	if err == nil {
		return TimeInForegroundFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TimeInForegroundFromJson(bytes io.Reader) TimeInForeground {
	var timeInForeground TimeInForeground
	json.NewDecoder(bytes).Decode(&timeInForeground)
	return timeInForeground
}

type TriggerData struct {
	NumberOfAppSession   NumberOfAppSession   `json:"numberOfAppSession,omitempty"`
	TimeInForeground     TimeInForeground     `json:"timeInForeground,omitempty"`
	MobileappVersion     []string             `json:"mobileappVersion,omitempty"`
	Submitted            NumberOfDays         `json:"submitted,omitempty"`
	Declined             NumberOfDays         `json:"declined,omitempty"`
	MobileosVersion      []string             `json:"mobileosVersion,omitempty"`
	PercentageOfSessions PercentageOfSessions `json:"percentageOfSessions,omitempty"`
	GenericRule          string               `json:"genericRule,omitempty"`
}

func TriggerDataFromMap(data interface{}) TriggerData {
	b, err := json.Marshal(data)
	if err == nil {
		return TriggerDataFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TriggerDataFromJson(bytes io.Reader) TriggerData {
	var triggerData TriggerData
	json.NewDecoder(bytes).Decode(&triggerData)
	return triggerData
}

/**
 * Represents the question or fields to be filled by the user
 */
type ComponentUnion struct {
	ComponentLabel         ComponentLabel
	ComponentImage         ComponentImage
	ComponentNps           ComponentNps
	ComponentTextArea      ComponentTextArea
	ComponentTextInput     ComponentTextInput
	ComponentRadioSelector ComponentRadioSelector
	ComponentCheckbox      ComponentCheckbox
	ComponentDropdown      ComponentDropdown
	ComponentGrading       ComponentGrading
	ComponentGrading0to10  ComponentGrading0to10
	ComponentGrading1to10  ComponentGrading1to10
	Undefined              string
}

func ComponentUnionFromMap(data interface{}) ComponentUnion {
	b, err := json.Marshal(data)
	if err == nil {
		return ComponentUnionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ComponentUnionFromJson(bytes io.Reader) ComponentUnion {
	var el map[string]interface{}
	json.NewDecoder(bytes).Decode(&el)
	switch el["component"] {
	case "component_label":
		return ComponentUnion{ComponentLabel: ComponentLabelFromMap(el)}
	case "component_image":
		return ComponentUnion{ComponentImage: ComponentImageFromMap(el)}
	case "component_nps":
		return ComponentUnion{ComponentNps: ComponentNpsFromMap(el)}
	case "component_textArea":
		return ComponentUnion{ComponentTextArea: ComponentTextAreaFromMap(el)}
	case "component_textInput":
		return ComponentUnion{ComponentTextInput: ComponentTextInputFromMap(el)}
	case "component_radioSelector":
		return ComponentUnion{ComponentRadioSelector: ComponentRadioSelectorFromMap(el)}
	case "component_checkbox":
		return ComponentUnion{ComponentCheckbox: ComponentCheckboxFromMap(el)}
	case "component_dropdown":
		return ComponentUnion{ComponentDropdown: ComponentDropdownFromMap(el)}
	case "component_grading":
		return ComponentUnion{ComponentGrading: ComponentGradingFromMap(el)}
	case "component_grading0to10":
		return ComponentUnion{ComponentGrading0to10: ComponentGrading0to10FromMap(el)}
	case "component_grading1to10":
		return ComponentUnion{ComponentGrading1to10: ComponentGrading1to10FromMap(el)}
	default:
		return ComponentUnion{Undefined: el["component"].(string)}
	}
}

/**
 * Represents the component or fields to be filled by the user
 */
type FeedbackUnion struct {
	FeedbackNps           FeedbackNps
	FeedbackTextArea      FeedbackTextArea
	FeedbackTextInput     FeedbackTextInput
	FeedbackRadioSelector FeedbackRadioSelector
	FeedbackCheckbox      FeedbackCheckbox
	FeedbackDropdown      FeedbackDropdown
	FeedbackGrading       FeedbackGrading
	FeedbackGrading0to10  FeedbackGrading0to10
	FeedbackGrading1to10  FeedbackGrading1to10
	Undefined             string
}

func FeedbackUnionFromMap(data interface{}) FeedbackUnion {
	b, err := json.Marshal(data)
	if err == nil {
		return FeedbackUnionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FeedbackUnionFromJson(bytes io.Reader) FeedbackUnion {
	var el map[string]interface{}
	json.NewDecoder(bytes).Decode(&el)
	switch el["component"] {
	case "feedback_nps":
		return FeedbackUnion{FeedbackNps: FeedbackNpsFromMap(el)}
	case "feedback_textArea":
		return FeedbackUnion{FeedbackTextArea: FeedbackTextAreaFromMap(el)}
	case "feedback_textInput":
		return FeedbackUnion{FeedbackTextInput: FeedbackTextInputFromMap(el)}
	case "feedback_radioSelector":
		return FeedbackUnion{FeedbackRadioSelector: FeedbackRadioSelectorFromMap(el)}
	case "feedback_checkbox":
		return FeedbackUnion{FeedbackCheckbox: FeedbackCheckboxFromMap(el)}
	case "feedback_dropdown":
		return FeedbackUnion{FeedbackDropdown: FeedbackDropdownFromMap(el)}
	case "feedback_grading":
		return FeedbackUnion{FeedbackGrading: FeedbackGradingFromMap(el)}
	case "feedback_grading0to10":
		return FeedbackUnion{FeedbackGrading0to10: FeedbackGrading0to10FromMap(el)}
	case "feedback_grading1to10":
		return FeedbackUnion{FeedbackGrading1to10: FeedbackGrading1to10FromMap(el)}
	default:
		return FeedbackUnion{Undefined: el["component"].(string)}
	}
}

type AccessTokenWrappersPostAccessTokenResponse struct {
	StatusCode         int
	Response           *http.Response
	Error              error
	AccessTokenWrapper AccessTokenWrapper
}

func AccessTokenWrappersPostAccessToken(client Client) AccessTokenWrappersPostAccessTokenResponse {

	requestUrl := fmt.Sprintf("%s/accessToken", client.BaseUrl)

	request, err := buildRequest(client, "POST", requestUrl, ClientRequestBody{})
	if err != nil {
		return AccessTokenWrappersPostAccessTokenResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return AccessTokenWrappersPostAccessTokenResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return AccessTokenWrappersPostAccessTokenResponse{StatusCode: resp.StatusCode, Response: resp, AccessTokenWrapper: AccessTokenWrapperFromJson(resp.Body)}

	case 401:
		return AccessTokenWrappersPostAccessTokenResponse{StatusCode: resp.StatusCode, Response: resp}

	case 500:
		return AccessTokenWrappersPostAccessTokenResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return AccessTokenWrappersPostAccessTokenResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type ConfigurationsGetConfigurationResponse struct {
	StatusCode    int
	Response      *http.Response
	Error         error
	Configuration Configuration
}

func ConfigurationsGetConfiguration(client Client) ConfigurationsGetConfigurationResponse {

	requestUrl := fmt.Sprintf("%s/configuration", client.BaseUrl)

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return ConfigurationsGetConfigurationResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return ConfigurationsGetConfigurationResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return ConfigurationsGetConfigurationResponse{StatusCode: resp.StatusCode, Response: resp, Configuration: ConfigurationFromJson(resp.Body)}

	case 400:
		return ConfigurationsGetConfigurationResponse{StatusCode: resp.StatusCode, Response: resp}

	case 401:
		return ConfigurationsGetConfigurationResponse{StatusCode: resp.StatusCode, Response: resp}

	case 500:
		return ConfigurationsGetConfigurationResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return ConfigurationsGetConfigurationResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type FeedbacksPostFeedbackResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
}

func FeedbacksPostFeedback(client Client, feedback Feedback) FeedbacksPostFeedbackResponse {

	requestUrl := fmt.Sprintf("%s/feedback", client.BaseUrl)

	bodyDocument, err := json.Marshal(feedback)
	if err != nil {
		return FeedbacksPostFeedbackResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return FeedbacksPostFeedbackResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return FeedbacksPostFeedbackResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return FeedbacksPostFeedbackResponse{StatusCode: resp.StatusCode, Response: resp}

	case 400:
		return FeedbacksPostFeedbackResponse{StatusCode: resp.StatusCode, Response: resp}

	case 401:
		return FeedbacksPostFeedbackResponse{StatusCode: resp.StatusCode, Response: resp}

	case 500:
		return FeedbacksPostFeedbackResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return FeedbacksPostFeedbackResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

func buildRequest(client Client, method, urlStr string, body ClientRequestBody) (*http.Request, error) {

	request, err := http.NewRequest(method, urlStr, body.bytes)
	if err != nil {
		return nil, err
	}

	request.Header.Add("User-Agent",             UserAgent)
	request.Header.Add("X-Apidoc-Version",       Version)
	request.Header.Add("X-Apidoc-Version-Major", strconv.Itoa(VersionMajor))

	if client.Headers != nil {
		for key, values := range client.Headers {
			for _, value := range values {
				request.Header.Add(key, value)
			}
		}
	}

	if body.contentType != "" {
		request.Header.Add("Content-Type", body.contentType)
	}

	if client.Username != "" {
		request.SetBasicAuth(client.Username, client.Password)
	}

	return request, nil

}