class PIM::DirectPublication

# File pim.rb, line 12253
    def self.create enabled = true,
                    from: nil,
                    to: nil,
#                    filter_key: nil,
#                    filter_keys: nil,
                    filter_value: nil,
                    filter_member: nil,
                    filter_member_match_value: nil,
#                    map_key: nil,
#                    map_keys: nil,
                    map_value: nil,
                    match: nil,
                    revalidate: nil,
                    revalidate_attributes: nil

      from = ValueFilter.create(from, types: TYPES) unless from.nil?
      to = ValueFilter.create(to, types: TYPES) unless to.nil?

#      raise "'filter_keys' must be nil or a Hash" unless (filter_keys.nil? or PIM.is_hash?(filter_keys))
#      raise "'map_keys' must be nil or a Hash" unless (map_keys.nil? or PIM.is_hash?(map_keys))

#      filter_key = ValueFilter.create(filter_key, types: TYPES) unless filter_key.nil?
#      filter_keys = filter_keys.map { |k,v| [k, ValueFilter.create(v, types: TYPES)] }.to_h unless filter_keys.nil?
      filter_value = ValueFilter.create(filter_value, types: TYPES) unless filter_value.nil?

      unless filter_member.nil?
        filter_member = filter_member.to_s
        raise "'filter_member' must be a non-empty String" if filter_member.empty?
      end

      raise "'filter_member_match_value' requires 'filter_member'" \
        if filter_member.nil? and !filter_member_match_value.nil?

      raise "'filter_member' requires 'filter_member_match_value'" \
        if !filter_member.nil? and filter_member_match_value.nil?

      filter_member_match_value =
        ValueFilter.create(filter_member_match_value, types: TYPES) unless filter_member_match_value.nil?

#      map_key = map_key.to_s unless map_key.nil?
#      map_keys = map_key.to_s unless map_keys.nil?
      # Bare String: always evaluated as Jexl Script (EvaluationType.SCRIPT).
      map_value = map_value.to_s unless map_value.nil?

      match = ValueFilter.create(match, types: TYPES) unless match.nil?

      raise "'revalidate' must be nil or true or false" \
        unless revalidate.nil? or [true, false].include?(revalidate)

      raise "'revalidate_attributes' must be nil or an Array" \
        unless revalidate_attributes.nil? or PIM.is_array?(revalidate_attributes)

      revalidate = !(filter_value.nil? and map_value.nil? and filter_member.nil?) if revalidate.nil?

      self.new(enabled: enabled,
               from: from,
               to: to,
#               filter_key: filter_key,
#               filter_keys: filter_keys,
               filter_value: filter_value,
               filter_member: filter_member,
               filter_member_match_value: filter_member_match_value,
#               map_key: map_key,
#               map_keys: map_keys,
               map_value: map_value,
               match: match,
               revalidate: revalidate,
               revalidate_attributes: revalidate_attributes)

    end

# File pim.rb, line 12324
def as_json
  PIM::Utils.camelize(self.to_h.filter { |k,v| !v.nil? })
end

# File pim.rb, line 12328
def to_json *args
  as_json.to_json(*args)
end

# File pim.rb, line 12332
def verify attribute

  verify_filter_member(attribute) unless filter_member.nil?

  # Ensure, filter_key and map_key is set correctly according to attribute
  return if filter_key.nil? and filter_keys.nil? and map_key.nil? and map_keys.nil?

  raise "Attribute must be provided to verify 'filter_key', 'filter_keys', 'map_key' or 'map_keys'" if attribute.nil?

  raise "'filter_key' and 'map_key' is only allowed on attribute of type 'Dimensional'" +
        ", but not on attribute '#{attribute.name}' of type  '#{attribute.type_name}'" \
        unless (filter_key.nil? and map_key.nil?) or attribute.type_name == 'Dimensional'

  raise "'filter_keys' and 'map_keys' is only allowed on attribute of type 'MultiDimensional'" +
        ", but not on attribute '#{attribute.name}' of type  '#{attribute.type_name}'" \
        unless (filter_keys.nil? and map_keys.nil?) or attribute.type_name == 'MultiDimensional'

  unless filter_keys.nil?

    raise "'filter_keys' on MultiDimensional attribute '#{attribute.name}' must be a non empty Hash" unless filter_keys.is_a?(Hash)
    key_members = attribute.base_class.key_members
    non_matching_keys = filter_keys.keys.select { |k| !key_members.include?(k) }
    raise "'filter_keys' on MultiDimensional attribute '#{attribute.name}' must be a Hash including any key member (#{key_members.join(', ')})" +
          ", but not #{non_matching_keys.join(', ')}" unless non_matching_keys.empty?

  end

  unless map_keys.nil?

    raise "'map_keys' on MultiDimensional attribute '#{attribute.name}' must be a non empty Hash" unless map_keys.is_a?(Hash)
    key_members = attribute.base_class.key_members
    non_matching_keys = map_keys.keys.select { |k| !key_members.include?(k) }
    raise "'map_keys' on MultiDimensional attribute '#{attribute.name}' must be a Hash including any key member (#{key_members.join(', ')})" +
          ", but not #{non_matching_keys.join(', ')}" unless non_matching_keys.empty?

  end

end