diff --git a/lib/puppet/type/rabbitmq_parameter.rb b/lib/puppet/type/rabbitmq_parameter.rb
index 71b15d8..66ac7e8 100644
--- a/lib/puppet/type/rabbitmq_parameter.rb
+++ b/lib/puppet/type/rabbitmq_parameter.rb
@@ -1,86 +1,105 @@
 Puppet::Type.newtype(:rabbitmq_parameter) do
   desc <<-DESC
 Type for managing rabbitmq parameters
 
 @example Create some rabbitmq_parameter resources
    rabbitmq_parameter { 'documentumShovel@/':
      component_name => '',
      value          => {
          'src-uri'    => 'amqp://',
          'src-queue'  => 'my-queue',
          'dest-uri'   => 'amqp://remote-server',
          'dest-queue' => 'another-queue',
      },
    }
    rabbitmq_parameter { 'documentumFed@/':
      component_name => 'federation-upstream',
      value          => {
          'uri'     => 'amqp://myserver',
          'expires' => '360000',
      },
    }
+   rabbitmq_parameter { 'documentumShovelNoMunging@/':
+     component_name => '',
+     value          => {
+         'src-uri'    => 'amqp://',
+         'src-exchange'  => 'my-exchange',
+         'src-exchange-key' => '6',
+         'src-queue'  => 'my-queue',
+         'dest-uri'   => 'amqp://remote-server',
+         'dest-exchange' => 'another-exchange',
+     },
+     autoconvert   => false,
+   }
 DESC
 
   ensurable do
     defaultto(:present)
     newvalue(:present) do
       provider.create
     end
     newvalue(:absent) do
       provider.destroy
     end
   end
 
   autorequire(:service) { 'rabbitmq-server' }
 
   validate do
     raise('component_name parameter is required.') if self[:ensure] == :present && provider.component_name.nil?
     raise('value parameter is required.') if self[:ensure] == :present && provider.value.nil?
   end
 
   newparam(:name, namevar: true) do
     desc 'combination of name@vhost to set parameter for'
     newvalues(%r{^\S+@\S+$})
   end
 
   newproperty(:component_name) do
     desc 'The component_name to use when setting parameter, eg: shovel or federation'
     validate do |value|
       resource.validate_component_name(value)
     end
   end
 
+  newparam(:autoconvert) do
+    desc 'whether numeric strings from `value` should be converted to int automatically'
+    newvalues(:true, :false)
+    defaultto(:true)
+  end
+
   newproperty(:value) do
     desc 'A hash of values to use with the component name you are setting'
     validate do |value|
       resource.validate_value(value)
     end
     munge do |value|
       resource.munge_value(value)
     end
   end
 
   autorequire(:rabbitmq_vhost) do
     [self[:name].split('@')[1]]
   end
 
   def validate_component_name(value)
     raise ArgumentError, 'component_name must be defined' if value.empty?
   end
 
   def validate_value(value)
     raise ArgumentError, 'Invalid value' unless [Hash].include?(value.class)
     value.each do |_k, v|
       unless [String, TrueClass, FalseClass, Array].include?(v.class)
         raise ArgumentError, 'Invalid value'
       end
     end
   end
 
   def munge_value(value)
+    return value if self[:autoconvert] == :false
     value.each do |k, v|
       value[k] = v.to_i if v =~ %r{\A[-+]?[0-9]+\z}
     end
     value
   end
 end
diff --git a/spec/unit/puppet/type/rabbitmq_parameter_spec.rb b/spec/unit/puppet/type/rabbitmq_parameter_spec.rb
index 0e4eee7..499e237 100644
--- a/spec/unit/puppet/type/rabbitmq_parameter_spec.rb
+++ b/spec/unit/puppet/type/rabbitmq_parameter_spec.rb
@@ -1,85 +1,93 @@
 require 'spec_helper'
 describe Puppet::Type.type(:rabbitmq_parameter) do
   let(:parameter) do
     Puppet::Type.type(:rabbitmq_parameter).new(
       name: 'documentumShovel@/',
       component_name: 'shovel',
       value: {
         'src-uri' => 'amqp://myremote-server',
         'src-queue' => 'queue.docs.outgoing',
         'dest-uri' => 'amqp://',
         'dest-queue' => 'queue.docs.incoming'
       }
     )
   end
 
   it 'accepts a valid name' do
     parameter[:name] = 'documentumShovel@/'
     expect(parameter[:name]).to eq('documentumShovel@/')
   end
 
   it 'requires a name' do
     expect do
       Puppet::Type.type(:rabbitmq_parameter).new({})
     end.to raise_error(Puppet::Error, 'Title or name must be provided')
   end
 
   it 'fails when name does not have a @' do
     expect do
       parameter[:name] = 'documentumShovel'
     end.to raise_error(Puppet::Error, %r{Valid values match})
   end
 
   it 'accepts a string' do
     parameter[:component_name] = 'mystring'
     expect(parameter[:component_name]).to eq('mystring')
   end
 
   it 'is not empty' do
     expect do
       parameter[:component_name] = ''
     end.to raise_error(Puppet::Error, %r{component_name must be defined})
   end
 
   it 'accepts a valid hash for value' do
     value = { 'message-ttl' => '1800000' }
     parameter[:value] = value
     expect(parameter[:value]).to eq(value)
   end
 
   it 'does not accept an empty string for definition' do
     expect do
       parameter[:value] = ''
     end.to raise_error(Puppet::Error, %r{Invalid value})
   end
 
   it 'does not accept a string for definition' do
     expect do
       parameter[:value] = 'guest'
     end.to raise_error(Puppet::Error, %r{Invalid value})
   end
 
   it 'does not accept an object for definition' do
     expect do
       parameter[:value] = { 'message-ttl' => Object.new }
     end.to raise_error(Puppet::Error, %r{Invalid value})
   end
 
   it 'accepts array as myparameter' do
     value = { 'myparameter' => %w[my string] }
     parameter[:value] = value
     expect(parameter[:value]['myparameter']).to eq(%w[my string])
   end
 
   it 'accepts string as myparameter' do
     value = { 'myparameter' => 'mystring' }
     parameter[:value] = value
     expect(parameter[:value]['myparameter']).to eq('mystring')
   end
 
   it 'converts to integer when string only contains numbers' do
     value = { 'myparameter' => '1800000' }
     parameter[:value] = value
     expect(parameter[:value]['myparameter']).to eq(1_800_000)
   end
+
+  it 'does not convert numeric string to integer when autoconvert is set to false' do
+    parameter[:autoconvert] = false
+    value = { 'myparameter' => '1800000' }
+    parameter[:value] = value
+    expect(parameter[:value]['myparameter']).to eq('1800000')
+    expect(parameter[:value]['myparameter']).to be_kind_of(String)
+  end
 end