import { n as normalizeComponent, u as use, r as registerComponent } from './normalize-component-63e8c7a0.js';
import { _ as _defineProperty } from './defineProperty-18999f8e.js';
import { _ as _objectSpread2 } from './objectSpread2-605331b1.js';
import { a as _arrayWithHoles, b as _nonIterableRest, s as sort, _ as _slicedToArray, h as hasData, c as createId } from './utils-21c04279.js';
import { a as _iterableToArray, _ as _toConsumableArray } from './toConsumableArray-fb122614.js';
import { _ as _unsupportedIterableToArray } from './unsupportedIterableToArray-577176bf.js';
import './es.object.to-string-5a59fbfc.js';
import './es.number.constructor-16a232f3.js';
import './es.array.includes-1f433385.js';
import './es.string.includes-53dbb113.js';
import './es.object.keys-6369b884.js';
import './es.array.concat-9f3136dc.js';
import './es.array.map-093cfbca.js';
import './es.array.filter-9f634d7c.js';
import './es.json.stringify-9b0e9796.js';
import './es.array.slice-e9c3dd03.js';
import './regexp-exec-abstract-04d119fc.js';
import './es.string.search-d018b707.js';
import { B as BaseAdvancedSearchRow } from './BaseAdvancedSearchRow-4125f5b7.js';
import './es.array.sort-92cbfa54.js';
import './typeof-6c6d8d7a.js';
import './es.array.join-6ca857ff.js';
import './export-ecf4b1cb.js';
import './array-method-is-strict-903f485b.js';
import './es.string.split-cd1f3afc.js';
import './is-regexp-5558fd03.js';
import './function-bind-context-b3fabf77.js';
import './es.regexp.to-string-784af81c.js';
import './regexp-flags-b5fc4ddb.js';
import './es.string.replace-07eeebfe.js';
import './web.dom-collections.for-each-917714ef.js';
import './dom-iterables-b6f5ef3b.js';
import './array-iteration-dec5536e.js';
import './array-species-create-afb281e6.js';
import './classof-b10e7604.js';
import './object-set-prototype-of-9853ad1a.js';
import './object-keys-a5d351f7.js';
import './create-property-c00b5c27.js';
import './array-method-has-species-support-d96108b0.js';
import './string-multibyte-88926e02.js';
import './i18n-e25edebe.js';
import './es.array.from-3ef944e4.js';
import './es.string.iterator-eb7ab984.js';
import './set-to-string-tag-452fb9b0.js';
import './BaseSearch-eb4ae1e8.js';
import './BaseIcon-d03b1fa2.js';
import './BaseButton-44a621e1.js';
import './es.symbol.description-3b56bced.js';
import './BaseBoxTooltip-e7e1d52e.js';
import './BaseChipsInputField-9d9254f8.js';
import './BaseInput-aea1e5fe.js';
import './index-b4d779f7.js';
import './vuedraggable.umd-8fe09713.js';
import './navigateList-733ab7c4.js';
import './BaseChip-a5109284.js';
import './BaseHoverBox-54eeaa46.js';
import './BaseImageBox-4087fcc1.js';
import './BaseBox-a4447dc8.js';
import './BaseImage-7306e391.js';
import './es.object.values-a2198dd7.js';
import 'lazysizes';
import './BaseDropDownList-4893c704.js';

function _toArray(arr) {
  return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest();
}

/**
 * @typedef Filter
 * @property {string} label|* - property 'label' indicating the label or an equivalent
 *  custom property defined in prop labelPropertyName.filter
 * @property {string} id|* - property 'id' used as unique identifier or an equivalent
 *  custom property defined in prop identifierPropertyName.filter
 * @property {string} type - a filter type defining the type of search element shown
 *  @values text, chips, date, daterange
 * @property {boolean} [hidden] - exclude filters that have this attribute true from display
 * @property {boolean} [freetext_allowed] - property specifc for type: chips determining
 *  if options are autocompleted (true) or used from the options property (false)
 * @property {Object[]} [options] - the options used for chips filter types with
 *  freetext_allowed false
 * @property {Object[]|string[]|string|Object} [filter_values] - the values a filter contains - only
 *  relevant for applied filters, not for filters coming from backend presented in the drop down
 */

var script = {
  name: 'BaseAdvancedSearch',
  components: {
    BaseAdvancedSearchRow: BaseAdvancedSearchRow
  },
  props: {
    /**
     * list of available filters, needs to be an array of objects with the following properties:<br>
     *   <br>
     *    <b>label</b> {string} - the label of the filter (displayed
     *      if not main search) - this prop can be customized by specifying
     *      labelPropertyName.filter<br>
     *    <b>id</b> {string} - the identifier of the filter (displayed
     *      if not main search) - this prop can be customized by specifying
     *      identifierPropertyName.filter<br>
     *    <b>type</b> {('text'|'chips'|'date'|'daterange')} - the filter type<br>
     *    <b>hidden</b> {boolean} - filters with this attribute true will be filtered from
     *      displayed filter list<br>
     *    <b>freetext_allowed</b> {boolean} - determines if predetermined options from 'options'
     *      property are used or autocomplete is used
     *    <b>options</b> {Object[]} - for filter type 'chips' the controlled
     *      vocabulary options
     */
    filterList: {
      type: Array,
      default: function _default() {
        return [];
      },
      validator: function validator(val) {
        return !val.length // make sure a filter type is present and type is other than chips or freetext is
        // allowed - otherwise it needs to have an options property
        || val.every(function (v) {
          return !!v.type && (v.type !== 'chips' || v.freetext_allowed || !!v.options);
        });
      }
    },

    /**
     * possibility to set applied filters from outside, for necessary object properties
     * see filterList (except options - these are not necessary for applied filters)
     */
    appliedFilters: {
      type: Array,
      default: function _default() {
        return [];
      },
      // dont check for options on applied filters - not necessary
      validator: function validator(val) {
        return !val.length || val.every(function (v) {
          return v.type;
        });
      }
    },

    /**
     * provide the component with the fetched autocomplete results
     * (drop down options)<br>
     * this needs to be an object array with the properties specified in
     * `autocompletePropertyNames`
     */
    autocompleteResults: {
      type: Array,
      default: function _default() {
        return [];
      }
    },

    /**
     * specify a default value for a filter that is set when none of the
     * available filters is selected, should have the following properties:<br>
     *   <br>
     *    <b>label</b> {string} - the label of the filter (displayed
     *      if not main search) - this prop can be customized by specifying
     *      labelPropertyName.filter<br>
     *    <b>id</b> {string} - the identifier of the filter (displayed
     *      if not main search) - this prop can be customized by specifying
     *      identifierPropertyName.filter<br>
     *    <b>type</b> {('text'|'chips'|'date'|'daterange')} - the filter type<br>
     *    <b>options</b> {Object[]} - for filter type 'chips' the controlled
     *      vocabulary options<br>
     *    <b>filter_values</b> {Object[]|string[]|Object} - the values selected - object for date
     *    or array of objects or strings for type 'text' and type 'chips'
     */
    defaultFilter: {
      type: Object,
      default: function _default() {
        return {
          label: 'Fulltext',
          id: 'default',
          type: 'text',
          options: [],
          filter_values: []
        };
      },
      validator: function validator(val) {
        return val === null || val.type && (val.type !== 'chips' || val.options);
      }
    },

    /**
     * specify a language (ISO 639-1) (used for label if label is language specific object
     * e.g. { de: 'xxx', en: 'yyy' })
     */
    language: {
      type: String,
      default: ''
    },

    /**
     * set the row loader from outside per row index
     */
    isLoadingIndex: {
      type: Number,
      default: -1
    },

    /**
     * specify informational texts for the component - this needs to be an object with the following
     * properties (if you dont want to display any text leave an empty string:  <br>
     *   <br>
     *     <b>title</b>: text shown as first line on the drop down in filters area<br>
     *     <b>subtext</b>: text shown as second line on the drop down in filters area<br>
     *     <b>availableOptions</b>: text shown with chips options for controlled vocabulary
     *     search<br>
     *     <b>addFilter</b>: text/label used for add filter icon<br>
     *     <b>removeFilter</b>: text/label used for remove filter icon<br>
     *     <b>selectFilterLabel</b>: label (not visible) used for filter chips input field<br>
     *     <b>searchLabel</b>: label (not visible) used for search input field<br>
     *  <br>
     *  The values of this object might be plain text or a key for an i18n file<br>
     * This prop can be ignored when the 'no-options' slot is used.
     */
    advancedSearchText: {
      type: Object,
      default: function _default() {
        return {
          title: 'Advanced Search',
          subtext: 'Select a filter',
          availableOptions: 'Available options',
          addFilter: 'Add filter',
          removeFilter: 'Remove filter',
          selectFilterLabel: 'Select filter',
          searchLabel: 'Search for Entries'
        };
      },
      // checking if all necessary properties are part of the provided object
      validator: function validator(val) {
        return ['title', 'subtext', 'availableOptions', 'addFilter', 'removeFilter', 'selectFilterLabel', 'searchLabel'].every(function (prop) {
          return Object.keys(val).includes(prop);
        });
      }
    },

    /**
     * specify informational texts for the drop down - this needs to be an object with the following
     * properties:  <br>
     *   <br>
     *     <b>autocompleteNoOptions</b>: info text shown when autocomplete search does not yield
     *        any results <br>
     *     <b>autocompleteOngoing</b>: info text displayed while autocomplete search is ongoing
     *        (and no previous results are displayed)<br>
     *     <b>autocompleteInitial</b>: info text shown when user first opens the search
     *        component<br>
     *     <b>chipsNoOptions</b>: info text shown when no options for controlled vocabulary search
     *        are available (anymore)<br>
     *     <b>chipsMaxOptions</b>: text displayed if more than max number of options that can be
     *        displayed are available (configure via prop maxNumberControlledOptions)<br>
     *     <b>chipsNoMatch</b>: text displayed if string in input does not match any options<br>
     *     <b>chipsOngoing</b>: info text shown when controlled vocabulary chips are being
     *        fetched<br>
     *  <br>
     *  The values of this object might be plain text or a key for an i18n file<br>
     * This prop can be ignored when the 'no-options' slot is used.
     */
    dropDownInfoTexts: {
      type: Object,
      default: function _default() {
        return {
          autocompleteNoOptions: 'No matching options found',
          autocompleteOngoing: 'Autocomplete is being fetched...',
          autocompleteInitial: 'Please start typing or select a filter to see options',
          chipsNoOptions: 'No more options available',
          chipsMaxOptions: 'Please start typing to see options',
          chipsNoMatch: 'No matching options were found',
          chipsOngoing: 'Options are being loaded...'
        };
      },
      // checking if all necessary properties are part of the provided object
      validator: function validator(val) {
        return ['autocompleteNoOptions', 'autocompleteOngoing', 'autocompleteInitial', 'chipsNoOptions', 'chipsOngoing', 'chipsMaxOptions', 'chipsNoMatch'].every(function (prop) {
          return Object.keys(val).includes(prop);
        });
      }
    },

    /**
     * add a place holder for the search input, either a string used for every row or
     * add separate values for main filter row and already added filters<br>
     * properties:<br>
     *     <b>filterRow</b>: for already added filter rows<br>
     *     <b>main</b>: for the primary search input field<br>
     *
     *  each of these specific placeholders can again be a string or an object with different
     *  placeholders for for each search type (text, chips, date)
     */
    placeholder: {
      type: [Object, String],
      default: function _default() {
        return {
          filterRow: 'Add values to your filter',
          main: 'Search and Discover'
        };
      },
      validator: function validator(val) {
        return typeof val === 'string' || ['filterRow', 'main'].every(function (prop) {
          return Object.keys(val).includes(prop);
        });
      }
    },

    /**
     * specify the object property that can be used for identification of filters,
     * autocomplete options and controlled vocabulary options.<br>
     *   Could be a string (used for all of the mentioned objects) or an object with the following
     *   properties:<br>
     *     <b>filter</b>: identifier property name in filter objects<br>
     *     <b>autocompleteOption</b>: identifier property name in autocomplete option objects<br>
     *     <b>controlledVocabularyOption</b>: identifier property name in controlled
     *     vocabulary option objects<br>
     */
    identifierPropertyName: {
      type: [Object, String],
      default: function _default() {
        return {
          filter: 'id',
          autocompleteOption: 'id',
          controlledVocabularyOption: 'id'
        };
      }
    },

    /**
     * specify the object property that should be used for label display of filters,
     * autocomplete options and controlled vocabulary options.<br>
     *   Could be a string (used for all of the mentioned objects) or an object with the following
     *   properties:<br>
     *     <b>filter</b>: label property name in filter objects<br>
     *     <b>autocompleteOption</b>: label property name in autocomplete option objects<br>
     *     <b>controlledVocabularyOption</b>: label property name in controlled
     *     vocabulary option objects<br>
     */
    labelPropertyName: {
      type: [Object, String],
      default: function _default() {
        return {
          filter: 'label',
          autocompleteOption: 'title',
          controlledVocabularyOption: 'label'
        };
      }
    },

    /**
     * autocomplete results need a label and a data property that contains all the actual
     * autocomplete results for that specific category
     * TODO: make category optional
     */
    autocompletePropertyNames: {
      type: Object,
      default: function _default() {
        return {
          label: 'label',
          id: 'id',
          data: 'data'
        };
      },
      // check if all the necessary attributes are included in the provided object
      validator: function validator(val) {
        return ['id', 'label', 'data'].every(function (key) {
          return Object.keys(val).includes(key);
        });
      }
    },

    /**
     * this prop gives the option to add assistive text for screen readers<br>
     * properties:<br>
     * <b>selectedOption</b>: text read when a selected option is focused (currently only
     *  working for type chips with autocomplete (=freetext_allowed))
     */
    assistiveText: {
      type: Object,
      default: function _default() {
        return {};
      }
    },

    /**
     * if desired the box shadow around the search rows can be deactivated here
     */
    applyBoxShadow: {
      type: Boolean,
      default: true
    },

    /**
     * use this prop to set a delay in ms before date input calender is displayed
     */
    dateFieldDelay: {
      type: Number,
      default: 0
    }
  },
  data: function data() {
    return {
      /**
       * internal variable to handle applied filters also when set from outside
       * @type {Filter[]}
       */
      appliedFiltersInt: [],

      /**
       * the filter used in the main search field - not added to applied filters yet
       * @type {Filter}
       */
      mainFilter: null,

      /**
       * store the autocomplete results for each filter in this variable to have
       * it available even when other filter was used in the meantime
       * @type {Object[]}
       */
      filtersAutocompleteResults: [],

      /**
       * a variable storing the info for which filter autocomplete results were
       * requested
       * @type {number}
       */
      autocompleteIndex: -1,
      originalMainFilter: null
    };
  },
  computed: {
    /**
     * store the loading state of every filter
     *
     * @returns {boolean[]}
     */
    filtersLoadingState: function filtersLoadingState() {
      var _this = this;

      return [].concat(_toConsumableArray(this.appliedFiltersInt.map(function (filter, index) {
        return _this.autocompleteIndex === index;
      })), [// add one at the end for main search field (not added to applied filters array yet)
      this.autocompleteIndex === this.appliedFiltersInt.length]);
    },

    /**
     * the actually displayed filters
     * @returns {Filter[]}
     */
    displayedFilters: function displayedFilters() {
      // filter filters with property hidden true
      var displayed = _toConsumableArray(this.filterList).filter(function (f) {
        return !f.hidden;
      }); // sort them


      return sort(displayed, this.labelPropertyName.filter);
    },
    mainFilterIndex: function mainFilterIndex() {
      return this.appliedFilters.length - 1;
    }
  },
  watch: {
    /**
     * watch prop autocompleteResults to assign it to the correct filter row
     */
    autocompleteResults: function autocompleteResults(val) {
      // check if autocomplete is active for any field ( > -1 )
      if (this.autocompleteIndex >= 0) {
        // if yes set the results on the filter row active
        this.$set(this.filtersAutocompleteResults, this.autocompleteIndex, _toConsumableArray(val));
        this.autocompleteIndex = -1;
      }
    },

    /**
     * set autocomplete loading from outside
     */
    isLoadingIndex: function isLoadingIndex() {// this.autocompleteIndex = val;
    },

    /**
     * have appliedFilters in sync with parent to be able to set them from outside
     */
    appliedFiltersInt: {
      handler: function handler(val) {
        // check if val is actually different from prop value
        if (JSON.stringify(val) !== JSON.stringify(this.appliedFilters.slice(1))) {
          // if yes - inform parent
          this.$emit('update:applied-filters', [].concat(_toConsumableArray(val), [this.mainFilter]));
        }
      },
      deep: true
    },

    /**
     * have appliedFilters in sync with parent to be able to set them from outside
     */
    appliedFilters: {
      handler: function handler(val) {
        // check if value is different from internal value
        if (val && JSON.stringify(val.slice(0, -1)) !== JSON.stringify(this.appliedFiltersInt)) {
          // if yes - update internal value
          var _JSON$parse = JSON.parse(JSON.stringify([val].concat(_toConsumableArray(val.slice(0, -1)))));

          var _JSON$parse2 = _toArray(_JSON$parse);

          this.appliedFiltersInt = _JSON$parse2.slice(1);
        } // also check if main filter is different separately!


        if (val && val.length >= 1 && JSON.stringify(this.mainFilter) !== JSON.stringify(val[this.mainFilterIndex])) {
          var _JSON$parse3 = JSON.parse(JSON.stringify(val.slice(-1)));

          var _JSON$parse4 = _slicedToArray(_JSON$parse3, 1);

          this.mainFilter = _JSON$parse4[0];
        } else if (!val || val < 1) {
          this.mainFilter = _objectSpread2({}, this.defaultFilter);
        }
      },
      immediate: true
    },

    /**
     * watch main filter since changes are not directly handled via update:applied-filters
     * event and trigger search if anything changed
     * @param {Filter} val - the updated main filter
     */
    mainFilter: function mainFilter(val) {
      // make sure mainFilter exists and has property filter_values
      if (val && val.filter_values) {
        // store values to compare in variables
        var mainFilterHasData = hasData(val.filter_values); // for original filter also check right here if property filter_values actually
        // exists

        var originalMainFilterHasData = !!this.originalMainFilter && !!this.originalMainFilter.filter_values && hasData(this.originalMainFilter.filter_values); // now check a) if originalMainFilter exists already and
        // b) filter itself has switched (and there are actually data to search for)
        // c) original data and current data diverge (only one of them does not have data)
        // d) or both have data but data are different from each other

        if (this.originalMainFilter && (this.originalMainFilter.id !== val.id || mainFilterHasData !== originalMainFilterHasData || mainFilterHasData && originalMainFilterHasData && JSON.stringify(this.originalMainFilter.filter_values !== JSON.stringify(val.filter_values)))) {
          // if so - update original data
          this.originalMainFilter = JSON.parse(JSON.stringify(this.mainFilter)); // and trigger search

          this.search();
        }
      }
      /**
       * inform parent of changes in applied filters
       *
       * @event update:applied-filters
       * @type {Filter[]}
       */


      this.$emit('update:applied-filters', [].concat(_toConsumableArray(this.appliedFiltersInt), [val]));
    }
  },
  created: function created() {
    // check if mainFilter was already set (e.g. from outside)
    if (!this.mainFilter) {
      // if not set default filter
      this.mainFilter = JSON.parse(JSON.stringify(this.defaultFilter));
    }

    this.originalMainFilter = JSON.parse(JSON.stringify(this.mainFilter));
  },
  methods: {
    /**
     * function to add a filter row after '+' icon was triggered
     */
    addFilterRow: function addFilterRow(_ref) {
      var filter = _ref.filter,
          input = _ref.input;
      // first handle remaining input and add it to filter values if necessary
      // therefore have separate variable and assign the original values first (in case no
      // modifications are necessary)
      var newFilterValues = filter.type.includes('date') ? filter.filter_values : _toConsumableArray(filter.filter_values); // have variable for search trigger in case additional values are added and should trigger
      // search

      var triggerSearch = false; // now check if type is text and the current value saved in filter does not equal text input

      if (filter.type === 'text' && input.trim() && (!filter.filter_values || !filter.filter_values.length || this.mainFilter.filter_values[0] !== input.trim())) {
        // in that case assign new value and set search trigger true
        newFilterValues = [input];
        triggerSearch = true; // else if type is freetext chips add the value at the end of the array
      } else if (filter.type === 'chips' && filter.freetext_allowed && input.trim()) {
        newFilterValues = [].concat(_toConsumableArray(filter.filter_values), [_defineProperty({}, this.labelPropertyName.autocompleteOption, input)]); // also here triger search after

        triggerSearch = true;
      } // now finally add filter to internal filter list


      this.appliedFiltersInt.push(_objectSpread2(_objectSpread2({}, filter), {}, {
        filter_values: newFilterValues
      })); // and reset the main filter

      this.mainFilter = _objectSpread2({}, this.defaultFilter); // and store the main filter to compare to later

      this.originalMainFilter = JSON.parse(JSON.stringify(this.mainFilter)); // now check if search should be triggered

      if (triggerSearch) {
        this.search();
      }
    },

    /**
     * remove filter after 'x' was triggered
     * @param {Filter} filter - the filter to remove
     * @param {number} index - the index of the filter
     */
    removeFilter: function removeFilter(filter, index) {
      this.appliedFiltersInt.splice(index, 1); // trigger search to update search results

      this.search();
    },

    /**
     * function called when a filter object within a filter row changes
     * @param {Filter} filter - the filter that was altered
     * @param {number} index - the index of the filter
     */
    updateFilter: function updateFilter(filter, index) {
      this.$set(this.appliedFiltersInt, index, JSON.parse(JSON.stringify(filter))); // trigger search to update search results

      this.search();
    },

    /**
     * @param {string} string - the search string to autocomplete
     * @param {Filter} filter - the filter the autocomplete was triggered for
     * @param {number} index - the index of the filter
     */
    fetchAutocomplete: function fetchAutocomplete(_ref3, index) {
      var input = _ref3.input,
          filter = _ref3.filter;
      // set autocomplete variable to correct filter row
      this.autocompleteIndex = index;
      /**
       * inform parent to fetch autocomplete data for the provided filter
       *
       * @event fetch-autocomplete
       * @type {Object} - object with the following properties:
       * @property {string} searchString - the string to autocomplete
       * @property {Filter} filter - the filter object
       * @property {number} index - the filter index of all filters (main and applied)
       */

      this.$emit('fetch-autocomplete', {
        searchString: input,
        filter: filter,
        index: index
      });
    },

    /**
     * search function
     */
    search: function search() {
      /**
       * inform parent that search should be triggered
       *
       * @event search
       * @type {Filter[]}
       */
      this.$emit('search', [].concat(_toConsumableArray(this.appliedFiltersInt), [this.mainFilter]));
    },

    /**
     * create an internal row id for unique identification of added filter rows
     *
     * @returns {string}
     */
    getRowId: function getRowId() {
      // call utils function to return a "random" string
      return createId();
    }
  }
};

/* script */
var __vue_script__ = script;
/* template */

var __vue_render__ = function __vue_render__() {
  var _vm = this;

  var _h = _vm.$createElement;

  var _c = _vm._self._c || _h;

  return _c('div', {
    staticClass: "base-advanced-search"
  }, [_vm.appliedFiltersInt && _vm.appliedFiltersInt.length ? _vm._l(_vm.appliedFiltersInt, function (filter, index) {
    return _c('BaseAdvancedSearchRow', {
      key: 'filter-' + index,
      staticClass: "base-advanced-search__filter-row",
      attrs: {
        "search-row-id": _vm.getRowId(),
        "is-main-search": false,
        "autocomplete-results": _vm.filtersAutocompleteResults[index],
        "filter-list": _vm.displayedFilters,
        "applied-filter": filter,
        "is-loading": _vm.filtersLoadingState[index],
        "default-filter": _vm.defaultFilter,
        "placeholder": _vm.placeholder.filterRow || _vm.placeholder,
        "autocomplete-property-names": _vm.autocompletePropertyNames,
        "label-property-name": _vm.labelPropertyName,
        "identifier-property-name": _vm.identifierPropertyName,
        "drop-down-info-texts": _vm.dropDownInfoTexts,
        "advanced-search-text": _vm.advancedSearchText,
        "assistive-text": _vm.assistiveText,
        "date-field-delay": _vm.dateFieldDelay,
        "language": _vm.language
      },
      on: {
        "update:appliedFilter": function updateAppliedFilter($event) {
          filter = $event;
        },
        "update:applied-filter": [function ($event) {
          filter = $event;
        }, function ($event) {
          return _vm.updateFilter($event, index);
        }],
        "remove-filter": function removeFilter($event) {
          return _vm.removeFilter($event, index);
        },
        "fetch-autocomplete-results": function fetchAutocompleteResults($event) {
          return _vm.fetchAutocomplete($event, index);
        }
      }
    });
  }) : _vm._e(), _vm._v(" "), _c('BaseAdvancedSearchRow', _vm._b({
    attrs: {
      "search-row-id": 'main',
      "is-main-search": true,
      "applied-filter": _vm.mainFilter,
      "filter-list": _vm.displayedFilters,
      "default-filter": _vm.defaultFilter,
      "autocomplete-results": _vm.filtersAutocompleteResults[_vm.mainFilterIndex],
      "is-loading": _vm.filtersLoadingState[_vm.mainFilterIndex],
      "placeholder": _vm.placeholder.main || _vm.placeholder,
      "autocomplete-property-names": _vm.autocompletePropertyNames,
      "label-property-name": _vm.labelPropertyName,
      "identifier-property-name": _vm.identifierPropertyName,
      "drop-down-info-texts": _vm.dropDownInfoTexts,
      "advanced-search-text": _vm.advancedSearchText,
      "assistive-text": _vm.assistiveText,
      "date-field-delay": _vm.dateFieldDelay,
      "language": _vm.language
    },
    on: {
      "update:appliedFilter": function updateAppliedFilter($event) {
        _vm.mainFilter = $event;
      },
      "update:applied-filter": function updateAppliedFilter($event) {
        _vm.mainFilter = $event;
      },
      "add-filter-row": _vm.addFilterRow,
      "fetch-autocomplete-results": function fetchAutocompleteResults($event) {
        return _vm.fetchAutocomplete($event, _vm.mainFilterIndex);
      }
    }
  }, 'BaseAdvancedSearchRow', _vm.$listeners, false))], 2);
};

var __vue_staticRenderFns__ = [];
/* style */

var __vue_inject_styles__ = undefined;
/* scoped */

var __vue_scope_id__ = "data-v-2084149b";
/* module identifier */

var __vue_module_identifier__ = undefined;
/* functional template */

var __vue_is_functional_template__ = false;
/* style inject */

/* style inject SSR */

/* style inject shadow dom */

var __vue_component__ = /*#__PURE__*/normalizeComponent({
  render: __vue_render__,
  staticRenderFns: __vue_staticRenderFns__
}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, false, undefined, undefined, undefined);

var BaseAdvancedSearch = __vue_component__;

var Plugin = {
  install: function install(Vue) {
    registerComponent(Vue, BaseAdvancedSearch);
  }
};
use(Plugin);

export { BaseAdvancedSearch, Plugin as default };
