change const for the funtion params

73 files changed, 655 insertions, 655 deletions

diff --git a/dmagick/c/accelerate.d b/dmagick/c/accelerate.d
index ff5c9f0..d8519a6 100644
--- a/dmagick/c/accelerate.d
+++ b/dmagick/c/accelerate.d
@@ -5,4 +5,4 @@ import dmagick.c.image;
 import dmagick.c.magickType;
 import dmagick.c.morphology;
 
-extern(C) MagickBooleanType AccelerateConvolveImage(const Image*, const KernelInfo*, Image*, ExceptionInfo*);
+extern(C) MagickBooleanType AccelerateConvolveImage(const(Image)*, const(KernelInfo)*, Image*, ExceptionInfo*);
diff --git a/dmagick/c/animate.d b/dmagick/c/animate.d
index 3915e55..2d57a35 100644
--- a/dmagick/c/animate.d
+++ b/dmagick/c/animate.d
@@ -3,4 +3,4 @@ module dmagick.c.animate;
 import dmagick.c.image;
 import dmagick.c.magickType;
 
-extern(C) MagickBooleanType AnimateImages(const ImageInfo*, Image*);
+extern(C) MagickBooleanType AnimateImages(const(ImageInfo)*, Image*);
diff --git a/dmagick/c/annotate.d b/dmagick/c/annotate.d
index be4fc45..98d816e 100644
--- a/dmagick/c/annotate.d
+++ b/dmagick/c/annotate.d
@@ -8,9 +8,9 @@ import dmagick.c.magickType;
 
 extern(C)
 {
-	MagickBooleanType AnnotateImage(Image*, const DrawInfo*);
-	MagickBooleanType GetMultilineTypeMetrics(Image*, const DrawInfo*, TypeMetric*);
-	MagickBooleanType GetTypeMetrics(Image*, const DrawInfo*, TypeMetric*);
+	MagickBooleanType AnnotateImage(Image*, const(DrawInfo)*);
+	MagickBooleanType GetMultilineTypeMetrics(Image*, const(DrawInfo)*, TypeMetric*);
+	MagickBooleanType GetTypeMetrics(Image*, const(DrawInfo)*, TypeMetric*);
 
 	ssize_t FormatMagickCaption(Image*, DrawInfo*, const MagickBooleanType, TypeMetric*, char**);
 }
diff --git a/dmagick/c/artifact.d b/dmagick/c/artifact.d
index 2990346..2369c2c 100644
--- a/dmagick/c/artifact.d
+++ b/dmagick/c/artifact.d
@@ -5,16 +5,16 @@ import dmagick.c.magickType;
 
 extern(C)
 {
-	char* GetNextImageArtifact(const Image*);
-	char* RemoveImageArtifact(Image*, const char*);
+	char* GetNextImageArtifact(const(Image)*);
+	char* RemoveImageArtifact(Image*, const(char)*);
 
-	const(char)* GetImageArtifact(const Image*, const char*);
+	const(char)* GetImageArtifact(const(Image)*, const(char)*);
 
-	MagickBooleanType CloneImageArtifacts(Image*, const Image*);
-	MagickBooleanType DefineImageArtifact(Image*, const char*);
-	MagickBooleanType DeleteImageArtifact(Image*, const char*);
-	MagickBooleanType SetImageArtifact(Image*, const char*, const char*);
+	MagickBooleanType CloneImageArtifacts(Image*, const(Image)*);
+	MagickBooleanType DefineImageArtifact(Image*, const(char)*);
+	MagickBooleanType DeleteImageArtifact(Image*, const(char)*);
+	MagickBooleanType SetImageArtifact(Image*, const(char)*, const(char)*);
 
 	void DestroyImageArtifacts(Image*);
-	void ResetImageArtifactIterator(const Image*);
+	void ResetImageArtifactIterator(const(Image)*);
 }
diff --git a/dmagick/c/attribute.d b/dmagick/c/attribute.d
index c827155..dac183f 100644
--- a/dmagick/c/attribute.d
+++ b/dmagick/c/attribute.d
@@ -7,17 +7,17 @@ import dmagick.c.geometry;
 
 extern(C)
 {
-	ImageType GetImageType(const Image*, ExceptionInfo*);
+	ImageType GetImageType(const(Image)*, ExceptionInfo*);
 
-	MagickBooleanType IsGrayImage(const Image*, ExceptionInfo*);
-	MagickBooleanType IsMonochromeImage(const Image*, ExceptionInfo*);
-	MagickBooleanType IsOpaqueImage(const Image*, ExceptionInfo*);
+	MagickBooleanType IsGrayImage(const(Image)*, ExceptionInfo*);
+	MagickBooleanType IsMonochromeImage(const(Image)*, ExceptionInfo*);
+	MagickBooleanType IsOpaqueImage(const(Image)*, ExceptionInfo*);
 	MagickBooleanType SetImageChannelDepth(Image*, const ChannelType, const size_t);
 	MagickBooleanType SetImageDepth(Image*, const size_t);
 
-	RectangleInfo GetImageBoundingBox(const Image*, ExceptionInfo* exception);
+	RectangleInfo GetImageBoundingBox(const(Image)*, ExceptionInfo* exception);
 
-	size_t GetImageChannelDepth(const Image*, const ChannelType, ExceptionInfo*);
-	size_t GetImageDepth(const Image*, ExceptionInfo*);
-	size_t GetImageQuantumDepth(const Image*, const MagickBooleanType);
+	size_t GetImageChannelDepth(const(Image)*, const ChannelType, ExceptionInfo*);
+	size_t GetImageDepth(const(Image)*, ExceptionInfo*);
+	size_t GetImageQuantumDepth(const(Image)*, const MagickBooleanType);
 }
diff --git a/dmagick/c/blob.d b/dmagick/c/blob.d
index 95f3817..60fee58 100644
--- a/dmagick/c/blob.d
+++ b/dmagick/c/blob.d
@@ -16,30 +16,30 @@ extern(C)
 		IOMode
 	}
 
-	FILE* GetBlobFileHandle(const Image*);
+	FILE* GetBlobFileHandle(const(Image)*);
 
-	Image* BlobToImage(const ImageInfo*, const void*, const size_t, ExceptionInfo*);
-	Image* PingBlob(const ImageInfo*, const void*, const size_t, ExceptionInfo*);
+	Image* BlobToImage(const(ImageInfo)*, const(void)*, const size_t, ExceptionInfo*);
+	Image* PingBlob(const(ImageInfo)*, const(void)*, const size_t, ExceptionInfo*);
 
-	MagickBooleanType BlobToFile(char*, const void*, const size_t, ExceptionInfo*);
-	MagickBooleanType FileToImage(Image*, const char*);
-	MagickBooleanType GetBlobError(const Image*);
+	MagickBooleanType BlobToFile(char*, const(void)*, const size_t, ExceptionInfo*);
+	MagickBooleanType FileToImage(Image*, const(char)*);
+	MagickBooleanType GetBlobError(const(Image)*);
 	MagickBooleanType ImageToFile(Image*, char*, ExceptionInfo*);
-	MagickBooleanType InjectImageBlob(const ImageInfo*, Image*, Image*, const char*, ExceptionInfo*);
-	MagickBooleanType IsBlobExempt(const Image*);
-	MagickBooleanType IsBlobSeekable(const Image*);
-	MagickBooleanType IsBlobTemporary(const Image*);
+	MagickBooleanType InjectImageBlob(const(ImageInfo)*, Image*, Image*, const(char)*, ExceptionInfo*);
+	MagickBooleanType IsBlobExempt(const(Image)*);
+	MagickBooleanType IsBlobSeekable(const(Image)*);
+	MagickBooleanType IsBlobTemporary(const(Image)*);
 
-	MagickSizeType GetBlobSize(const Image*);
+	MagickSizeType GetBlobSize(const(Image)*);
 
-	StreamHandler GetBlobStreamHandler(const Image*);
+	StreamHandler GetBlobStreamHandler(const(Image)*);
 
-	ubyte* FileToBlob(const char*, const size_t, size_t*, ExceptionInfo*);
-	ubyte* GetBlobStreamData(const Image*);
-	ubyte* ImageToBlob(const ImageInfo*, Image*, size_t*, ExceptionInfo*);
-	ubyte* ImagesToBlob(const ImageInfo*, Image*, size_t*, ExceptionInfo*);
+	ubyte* FileToBlob(const(char)*, const size_t, size_t*, ExceptionInfo*);
+	ubyte* GetBlobStreamData(const(Image)*);
+	ubyte* ImageToBlob(const(ImageInfo)*, Image*, size_t*, ExceptionInfo*);
+	ubyte* ImagesToBlob(const(ImageInfo)*, Image*, size_t*, ExceptionInfo*);
 
 	void DestroyBlob(Image*);
-	void DuplicateBlob(Image*, const Image*);
+	void DuplicateBlob(Image*, const(Image)*);
 	void SetBlobExempt(Image*, const MagickBooleanType);
 }
diff --git a/dmagick/c/cache.d b/dmagick/c/cache.d
index a422a9b..adb4b12 100644
--- a/dmagick/c/cache.d
+++ b/dmagick/c/cache.d
@@ -10,31 +10,31 @@ import dmagick.c.cacheView;
 
 extern(C)
 {
-	const(IndexPacket)* GetVirtualIndexQueue(const Image*);
+	const(IndexPacket)* GetVirtualIndexQueue(const(Image)*);
 
-	const(PixelPacket)* GetVirtualPixels(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
-	const(PixelPacket)* GetVirtualPixelQueue(const Image*);
+	const(PixelPacket)* GetVirtualPixels(const(Image)*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
+	const(PixelPacket)* GetVirtualPixelQueue(const(Image)*);
 
-	const(void)* AcquirePixelCachePixels(const Image*, MagickSizeType*, ExceptionInfo*);
+	const(void)* AcquirePixelCachePixels(const(Image)*, MagickSizeType*, ExceptionInfo*);
 
-	IndexPacket* GetAuthenticIndexQueue(const Image*);
+	IndexPacket* GetAuthenticIndexQueue(const(Image)*);
 
 	MagickBooleanType CacheComponentGenesis();
-	MagickBooleanType GetOneVirtualMagickPixel(const Image*, const ssize_t, const ssize_t, MagickPixelPacket*, ExceptionInfo*);
-	MagickBooleanType GetOneVirtualPixel(const Image*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
-	MagickBooleanType GetOneVirtualMethodPixel(const Image*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType GetOneVirtualMagickPixel(const(Image)*, const ssize_t, const ssize_t, MagickPixelPacket*, ExceptionInfo*);
+	MagickBooleanType GetOneVirtualPixel(const(Image)*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType GetOneVirtualMethodPixel(const(Image)*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
 	MagickBooleanType GetOneAuthenticPixel(Image*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
-	MagickBooleanType PersistPixelCache(Image*, const char*, const MagickBooleanType, MagickOffsetType*, ExceptionInfo*);
+	MagickBooleanType PersistPixelCache(Image*, const(char)*, const MagickBooleanType, MagickOffsetType*, ExceptionInfo*);
 	MagickBooleanType SyncAuthenticPixels(Image*, ExceptionInfo*);
 
-	MagickSizeType GetImageExtent(const Image*);
+	MagickSizeType GetImageExtent(const(Image)*);
 
 	PixelPacket* GetAuthenticPixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
-	PixelPacket* GetAuthenticPixelQueue(const Image*);
+	PixelPacket* GetAuthenticPixelQueue(const(Image)*);
 	PixelPacket* QueueAuthenticPixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
 
-	VirtualPixelMethod GetPixelCacheVirtualMethod(const Image*);
-	VirtualPixelMethod SetPixelCacheVirtualMethod(const Image*, const VirtualPixelMethod);
+	VirtualPixelMethod GetPixelCacheVirtualMethod(const(Image)*);
+	VirtualPixelMethod SetPixelCacheVirtualMethod(const(Image)*, const VirtualPixelMethod);
 
 	void  CacheComponentTerminus();
 	void* GetPixelCachePixels(Image*, MagickSizeType*, ExceptionInfo*);
diff --git a/dmagick/c/cacheView.d b/dmagick/c/cacheView.d
index 53ae290..ee46f76 100644
--- a/dmagick/c/cacheView.d
+++ b/dmagick/c/cacheView.d
@@ -34,33 +34,33 @@ extern(C)
 
 	struct CacheView {}
 
-	ClassType GetCacheViewStorageClass(const CacheView*);
+	ClassType GetCacheViewStorageClass(const(CacheView)*);
 
-	ColorspaceType GetCacheViewColorspace(const CacheView*);
+	ColorspaceType GetCacheViewColorspace(const(CacheView)*);
 
-	const(IndexPacket)* GetCacheViewVirtualIndexQueue(const CacheView*);
+	const(IndexPacket)* GetCacheViewVirtualIndexQueue(const(CacheView)*);
 
-	const(PixelPacket)* GetCacheViewVirtualPixels(const CacheView*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
-	const(PixelPacket)* GetCacheViewVirtualPixelQueue(const CacheView*);
+	const(PixelPacket)* GetCacheViewVirtualPixels(const(CacheView)*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
+	const(PixelPacket)* GetCacheViewVirtualPixelQueue(const(CacheView)*);
 
-	ExceptionInfo* GetCacheViewException(const CacheView*);
+	ExceptionInfo* GetCacheViewException(const(CacheView)*);
 
 	IndexPacket* GetCacheViewAuthenticIndexQueue(CacheView*);
 
-	MagickBooleanType GetOneCacheViewVirtualPixel(const CacheView*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
-	MagickBooleanType GetOneCacheViewVirtualMethodPixel(const CacheView*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
-	MagickBooleanType GetOneCacheViewAuthenticPixel(const CacheView*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType GetOneCacheViewVirtualPixel(const(CacheView)*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType GetOneCacheViewVirtualMethodPixel(const(CacheView)*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType GetOneCacheViewAuthenticPixel(const(CacheView)*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
 	MagickBooleanType SetCacheViewStorageClass(CacheView*, const ClassType);
 	MagickBooleanType SetCacheViewVirtualPixelMethod(CacheView*, const VirtualPixelMethod);
 	MagickBooleanType SyncCacheViewAuthenticPixels(CacheView*, ExceptionInfo*);
 
-	MagickSizeType GetCacheViewExtent(const CacheView*);
+	MagickSizeType GetCacheViewExtent(const(CacheView)*);
 
 	PixelPacket* GetCacheViewAuthenticPixelQueue(CacheView*);
 	PixelPacket* GetCacheViewAuthenticPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
 	PixelPacket* QueueCacheViewAuthenticPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
 
-	CacheView* AcquireCacheView(const Image*);
-	CacheView* CloneCacheView(const CacheView*);
+	CacheView* AcquireCacheView(const(Image)*);
+	CacheView* CloneCacheView(const(CacheView)*);
 	CacheView* DestroyCacheView(CacheView*);
 }
diff --git a/dmagick/c/cipher.d b/dmagick/c/cipher.d
index be48b7a..0198da5 100644
--- a/dmagick/c/cipher.d
+++ b/dmagick/c/cipher.d
@@ -7,8 +7,8 @@ import dmagick.c.magickType;
 
 extern(C)
 {
-	MagickBooleanType DecipherImage(Image*, const char*, ExceptionInfo*);
-	MagickBooleanType EncipherImage(Image*, const char*, ExceptionInfo*);
-	MagickBooleanType PasskeyDecipherImage(Image*, const StringInfo*, ExceptionInfo*);
-	MagickBooleanType PasskeyEncipherImage(Image*, const StringInfo*, ExceptionInfo*);
+	MagickBooleanType DecipherImage(Image*, const(char)*, ExceptionInfo*);
+	MagickBooleanType EncipherImage(Image*, const(char)*, ExceptionInfo*);
+	MagickBooleanType PasskeyDecipherImage(Image*, const(StringInfo)*, ExceptionInfo*);
+	MagickBooleanType PasskeyEncipherImage(Image*, const(StringInfo)*, ExceptionInfo*);
 }
diff --git a/dmagick/c/client.d b/dmagick/c/client.d
index 49a6861..efc8bae 100644
--- a/dmagick/c/client.d
+++ b/dmagick/c/client.d
@@ -4,6 +4,6 @@ extern(C)
 {
 	const(char)* GetClientPath();
 	const(char)* GetClientName();
-	const(char)* SetClientName(const char*);
-	const(char)* SetClientPath(const char*);
+	const(char)* SetClientName(const(char)*);
+	const(char)* SetClientPath(const(char)*);
 }
diff --git a/dmagick/c/coder.d b/dmagick/c/coder.d
index f7990b2..58de630 100644
--- a/dmagick/c/coder.d
+++ b/dmagick/c/coder.d
@@ -26,10 +26,10 @@ extern(C)
 			signature;
 	}
 
-	char** GetCoderList(const char*, size_t*, ExceptionInfo*);
+	char** GetCoderList(const(char)*, size_t*, ExceptionInfo*);
 
-	const(CoderInfo)*  GetCoderInfo(const char*, ExceptionInfo*);
-	const(CoderInfo)** GetCoderInfoList(const char*, size_t*, ExceptionInfo*);
+	const(CoderInfo)*  GetCoderInfo(const(char)*, ExceptionInfo*);
+	const(CoderInfo)** GetCoderInfoList(const(char)*, size_t*, ExceptionInfo*);
 
 	MagickBooleanType CoderComponentGenesis();
 	MagickBooleanType ListCoderInfo(FILE*, ExceptionInfo*);
diff --git a/dmagick/c/color.d b/dmagick/c/color.d
index 44be838..6589b28 100644
--- a/dmagick/c/color.d
+++ b/dmagick/c/color.d
@@ -52,28 +52,28 @@ extern(C)
 			normalized_maximum_error;
 	}
 
-	char** GetColorList(const char*, size_t*, ExceptionInfo*);
+	char** GetColorList(const(char)*, size_t*, ExceptionInfo*);
 
-	const(ColorInfo)*  GetColorInfo(const char*, ExceptionInfo*);
-	const(ColorInfo)** GetColorInfoList(const char*, size_t*, ExceptionInfo*);
+	const(ColorInfo)*  GetColorInfo(const(char)*, ExceptionInfo*);
+	const(ColorInfo)** GetColorInfoList(const(char)*, size_t*, ExceptionInfo*);
 
 	MagickBooleanType ColorComponentGenesis();
-	MagickBooleanType IsColorSimilar(const Image*, const PixelPacket*, const PixelPacket*);
-	MagickBooleanType IsGrayImage(const Image*, ExceptionInfo*);
-	MagickBooleanType IsImageSimilar(const Image*, const Image*, ssize_t* x,ssize_t* y, ExceptionInfo*);
-	MagickBooleanType IsMagickColorSimilar(const MagickPixelPacket*, const MagickPixelPacket*);
-	MagickBooleanType IsMonochromeImage(const Image*, ExceptionInfo*);
-	MagickBooleanType IsOpacitySimilar(const Image*, const PixelPacket*, const PixelPacket*);
-	MagickBooleanType IsOpaqueImage(const Image*, ExceptionInfo*);
+	MagickBooleanType IsColorSimilar(const(Image)*, const(PixelPacket)*, const(PixelPacket)*);
+	MagickBooleanType IsGrayImage(const(Image)*, ExceptionInfo*);
+	MagickBooleanType IsImageSimilar(const(Image)*, const(Image)*, ssize_t* x,ssize_t* y, ExceptionInfo*);
+	MagickBooleanType IsMagickColorSimilar(const(MagickPixelPacket)*, const(MagickPixelPacket)*);
+	MagickBooleanType IsMonochromeImage(const(Image)*, ExceptionInfo*);
+	MagickBooleanType IsOpacitySimilar(const(Image)*, const(PixelPacket)*, const(PixelPacket)*);
+	MagickBooleanType IsOpaqueImage(const(Image)*, ExceptionInfo*);
 	MagickBooleanType ListColorInfo(FILE*, ExceptionInfo*);
-	MagickBooleanType QueryColorCompliance(const char*, const ComplianceType, PixelPacket*, ExceptionInfo*);
-	MagickBooleanType QueryColorDatabase(const char*, PixelPacket*, ExceptionInfo*);
-	MagickBooleanType QueryColorname(const Image*, const PixelPacket*, const ComplianceType, char*, ExceptionInfo*);
-	MagickBooleanType QueryMagickColorCompliance(const char*, const ComplianceType, MagickPixelPacket*, ExceptionInfo*);
-	MagickBooleanType QueryMagickColor(const char*, MagickPixelPacket*, ExceptionInfo*);
-	MagickBooleanType QueryMagickColorname(const Image*, const MagickPixelPacket*, const ComplianceType, char*, ExceptionInfo*);
+	MagickBooleanType QueryColorCompliance(const(char)*, const ComplianceType, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType QueryColorDatabase(const(char)*, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType QueryColorname(const(Image)*, const(PixelPacket)*, const ComplianceType, char*, ExceptionInfo*);
+	MagickBooleanType QueryMagickColorCompliance(const(char)*, const ComplianceType, MagickPixelPacket*, ExceptionInfo*);
+	MagickBooleanType QueryMagickColor(const(char)*, MagickPixelPacket*, ExceptionInfo*);
+	MagickBooleanType QueryMagickColorname(const(Image)*, const(MagickPixelPacket)*, const ComplianceType, char*, ExceptionInfo*);
 
 	void ColorComponentTerminus();
-	void ConcatenateColorComponent(const MagickPixelPacket*, const ChannelType, const ComplianceType, char*);
-	void GetColorTuple(const MagickPixelPacket*, const MagickBooleanType, char*);
+	void ConcatenateColorComponent(const(MagickPixelPacket)*, const ChannelType, const ComplianceType, char*);
+	void GetColorTuple(const(MagickPixelPacket)*, const MagickBooleanType, char*);
 }
diff --git a/dmagick/c/compare.d b/dmagick/c/compare.d
index b2a755f..b9b459a 100644
--- a/dmagick/c/compare.d
+++ b/dmagick/c/compare.d
@@ -19,13 +19,13 @@ extern(C)
 		RootMeanSquaredErrorMetric
 	}
 
-	double* GetImageChannelDistortions(Image*, const Image*, const MetricType, ExceptionInfo*);
+	double* GetImageChannelDistortions(Image*, const(Image)*, const MetricType, ExceptionInfo*);
 
-	Image* CompareImageChannels(Image*, const Image*, const ChannelType, const MetricType, double*, ExceptionInfo*);
-	Image* CompareImages(Image*, const Image*, const MetricType, double*, ExceptionInfo*);
-	Image* SimilarityImage(Image*, const Image*, RectangleInfo*, double*, ExceptionInfo*);
+	Image* CompareImageChannels(Image*, const(Image)*, const ChannelType, const MetricType, double*, ExceptionInfo*);
+	Image* CompareImages(Image*, const(Image)*, const MetricType, double*, ExceptionInfo*);
+	Image* SimilarityImage(Image*, const(Image)*, RectangleInfo*, double*, ExceptionInfo*);
 
-	MagickBooleanType GetImageChannelDistortion(Image*, const Image*, const ChannelType, const MetricType, double*, ExceptionInfo*);
-	MagickBooleanType GetImageDistortion(Image*, const Image*, const MetricType, double*, ExceptionInfo*);
-	MagickBooleanType IsImagesEqual(Image*, const Image*);
+	MagickBooleanType GetImageChannelDistortion(Image*, const(Image)*, const ChannelType, const MetricType, double*, ExceptionInfo*);
+	MagickBooleanType GetImageDistortion(Image*, const(Image)*, const MetricType, double*, ExceptionInfo*);
+	MagickBooleanType IsImagesEqual(Image*, const(Image)*);
 }
diff --git a/dmagick/c/composite.d b/dmagick/c/composite.d
index e280fc8..a1c8c6c 100644
--- a/dmagick/c/composite.d
+++ b/dmagick/c/composite.d
@@ -75,7 +75,7 @@ extern(C)
 		MathematicsCompositeOp
 	}
 
-	MagickBooleanType CompositeImage(Image*, const CompositeOperator, const Image*, const ssize_t, const ssize_t);
-	MagickBooleanType CompositeImageChannel(Image*, const ChannelType, const CompositeOperator, const Image*, const ssize_t, const ssize_t);
-	MagickBooleanType TextureImage(Image*, const Image*);
+	MagickBooleanType CompositeImage(Image*, const CompositeOperator, const(Image)*, const ssize_t, const ssize_t);
+	MagickBooleanType CompositeImageChannel(Image*, const ChannelType, const CompositeOperator, const(Image)*, const ssize_t, const ssize_t);
+	MagickBooleanType TextureImage(Image*, const(Image)*);
 }
diff --git a/dmagick/c/compress.d b/dmagick/c/compress.d
index bee6bfa..58003c8 100644
--- a/dmagick/c/compress.d
+++ b/dmagick/c/compress.d
@@ -31,7 +31,7 @@ extern(C)
 	struct Ascii85Info {}
 
 	MagickBooleanType HuffmanDecodeImage(Image*);
-	MagickBooleanType HuffmanEncodeImage(const ImageInfo*, Image*, Image*);
+	MagickBooleanType HuffmanEncodeImage(const(ImageInfo)*, Image*, Image*);
 	MagickBooleanType LZWEncodeImage(Image*, const size_t, ubyte*);
 	MagickBooleanType PackbitsEncodeImage(Image*, const size_t, ubyte*);
 	MagickBooleanType ZLIBEncodeImage(Image*, const size_t, ubyte*);
diff --git a/dmagick/c/configure.d b/dmagick/c/configure.d
index cb4a68f..febcdfa 100644
--- a/dmagick/c/configure.d
+++ b/dmagick/c/configure.d
@@ -27,17 +27,17 @@ extern(C)
 			signature;
 	}
 
-	char** GetConfigureList(const char*, size_t*, ExceptionInfo*);
-	char*  GetConfigureOption(const char*);
+	char** GetConfigureList(const(char)*, size_t*, ExceptionInfo*);
+	char*  GetConfigureOption(const(char)*);
 
-	const(char*) GetConfigureValue(const ConfigureInfo*);
+	const(char*) GetConfigureValue(const(ConfigureInfo)*);
 
-	const(ConfigureInfo)*  GetConfigureInfo(const char*, ExceptionInfo*);
-	const(ConfigureInfo)** GetConfigureInfoList(const char*, size_t*, ExceptionInfo*);
+	const(ConfigureInfo)*  GetConfigureInfo(const(char)*, ExceptionInfo*);
+	const(ConfigureInfo)** GetConfigureInfoList(const(char)*, size_t*, ExceptionInfo*);
 
 	LinkedListInfo* DestroyConfigureOptions(LinkedListInfo *);
-	LinkedListInfo* GetConfigurePaths(const char *,ExceptionInfo *);
-	LinkedListInfo* GetConfigureOptions(const char *,ExceptionInfo *);
+	LinkedListInfo* GetConfigurePaths(const(char)*,ExceptionInfo *);
+	LinkedListInfo* GetConfigureOptions(const(char)*,ExceptionInfo *);
 
 	MagickBooleanType ConfigureComponentGenesis();
 	MagickBooleanType ListConfigureInfo(FILE*, ExceptionInfo*);
diff --git a/dmagick/c/constitute.d b/dmagick/c/constitute.d
index ddf3de7..e23e9db 100644
--- a/dmagick/c/constitute.d
+++ b/dmagick/c/constitute.d
@@ -18,16 +18,16 @@ extern(C)
 		ShortPixel
 	}
 
-	Image* ConstituteImage(const size_t, const size_t, const char*, const StorageType, const void*, ExceptionInfo*);
-	Image* PingImage(const ImageInfo*, ExceptionInfo*);
-	Image* PingImages(const ImageInfo*, ExceptionInfo*);
-	Image* ReadImage(const ImageInfo*, ExceptionInfo*);
-	Image* ReadImages(const ImageInfo*, ExceptionInfo*);
-	Image* ReadInlineImage(const ImageInfo*, const char*, ExceptionInfo*);
+	Image* ConstituteImage(const size_t, const size_t, const(char)*, const StorageType, const(void)*, ExceptionInfo*);
+	Image* PingImage(const(ImageInfo)*, ExceptionInfo*);
+	Image* PingImages(const(ImageInfo)*, ExceptionInfo*);
+	Image* ReadImage(const(ImageInfo)*, ExceptionInfo*);
+	Image* ReadImages(const(ImageInfo)*, ExceptionInfo*);
+	Image* ReadInlineImage(const(ImageInfo)*, const(char)*, ExceptionInfo*);
 
 	MagickBooleanType ConstituteComponentGenesis();
-	MagickBooleanType WriteImage(const ImageInfo*, Image*);
-	MagickBooleanType WriteImages(const ImageInfo*, Image*, const char*, ExceptionInfo*);
+	MagickBooleanType WriteImage(const(ImageInfo)*, Image*);
+	MagickBooleanType WriteImages(const(ImageInfo)*, Image*, const(char)*, ExceptionInfo*);
 
 	void ConstituteComponentTerminus();
 }
diff --git a/dmagick/c/decorate.d b/dmagick/c/decorate.d
index 7aa15f1..5be3c80 100644
--- a/dmagick/c/decorate.d
+++ b/dmagick/c/decorate.d
@@ -22,8 +22,8 @@ extern(C)
 			outer_bevel;
 	}
 
-	Image* BorderImage(const Image*, const RectangleInfo*, ExceptionInfo*);
-	Image* FrameImage(const Image*, const FrameInfo*, ExceptionInfo*);
+	Image* BorderImage(const(Image)*, const(RectangleInfo)*, ExceptionInfo*);
+	Image* FrameImage(const(Image)*, const(FrameInfo)*, ExceptionInfo*);
 
-	MagickBooleanType RaiseImage(Image*, const RectangleInfo*, const MagickBooleanType);
+	MagickBooleanType RaiseImage(Image*, const(RectangleInfo)*, const MagickBooleanType);
 }
diff --git a/dmagick/c/deprecate.d b/dmagick/c/deprecate.d
index 5060a96..3700483 100644
--- a/dmagick/c/deprecate.d
+++ b/dmagick/c/deprecate.d
@@ -32,7 +32,7 @@ deprecated extern(C)
 
 	struct ViewInfo {}
 
-	alias MagickBooleanType function(const char*, const MagickOffsetType, const MagickSizeType, ExceptionInfo*) MonitorHandler;
+	alias MagickBooleanType function(const(char)*, const MagickOffsetType, const MagickSizeType, ExceptionInfo*) MonitorHandler;
 
 	struct ImageAttribute
 	{
@@ -49,142 +49,142 @@ deprecated extern(C)
 	}
 
 	CacheView* CloseCacheView(CacheView*);
-	CacheView* OpenCacheView(const Image*);
+	CacheView* OpenCacheView(const(Image)*);
 
-	char* AllocateString(const char*);
-	char* InterpretImageAttributes(const ImageInfo*, Image*, const char*);
-	char* PostscriptGeometry(const char*);
-	char* TranslateText(const ImageInfo *,Image *,const char *);
+	char* AllocateString(const(char)*);
+	char* InterpretImageAttributes(const(ImageInfo)*, Image*, const(char)*);
+	char* PostscriptGeometry(const(char)*);
+	char* TranslateText(const(ImageInfo)*, Image*, const(char)*);
 
-	const(ImageAttribute)* GetImageAttribute(const Image*, const char*);
+	const(ImageAttribute)* GetImageAttribute(const(Image)*, const(char)*);
 	const(ImageAttribute)* GetImageClippingPathAttribute(Image*);
-	const(ImageAttribute)* GetNextImageAttribute(const Image*);
-
-	const(IndexPacket)* AcquireCacheViewIndexes(const CacheView*);
-	const(IndexPacket)* AcquireIndexes(const Image*);
-
-	const(PixelPacket)* AcquirePixels(const Image*);
-	const(PixelPacket)* AcquireCacheViewPixels(const CacheView*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
-	const(PixelPacket)* AcquireImagePixels(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
-
-	Image* AllocateImage(const ImageInfo*);
-	Image* AverageImages(const Image*, ExceptionInfo*);
-	Image* ExtractSubimageFromImage(Image*, const Image*, ExceptionInfo*);
-	Image* GetImageFromMagickRegistry(const char*, ssize_t* id, ExceptionInfo*);
-	Image* GetImageList(const Image*, const ssize_t, ExceptionInfo*);
-	Image* GetNextImage(const Image*);
-	Image* GetPreviousImage(const Image*);
+	const(ImageAttribute)* GetNextImageAttribute(const(Image)*);
+
+	const(IndexPacket)* AcquireCacheViewIndexes(const(CacheView)*);
+	const(IndexPacket)* AcquireIndexes(const(Image)*);
+
+	const(PixelPacket)* AcquirePixels(const(Image)*);
+	const(PixelPacket)* AcquireCacheViewPixels(const(CacheView)*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
+	const(PixelPacket)* AcquireImagePixels(const(Image)*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
+
+	Image* AllocateImage(const(ImageInfo)*);
+	Image* AverageImages(const(Image)*, ExceptionInfo*);
+	Image* ExtractSubimageFromImage(Image*, const(Image)*, ExceptionInfo*);
+	Image* GetImageFromMagickRegistry(const(char)*, ssize_t* id, ExceptionInfo*);
+	Image* GetImageList(const(Image)*, const ssize_t, ExceptionInfo*);
+	Image* GetNextImage(const(Image)*);
+	Image* GetPreviousImage(const(Image)*);
 	Image* FlattenImages(Image*, ExceptionInfo*);
-	Image* MaximumImages(const Image*, ExceptionInfo*);
-	Image* MinimumImages(const Image*, ExceptionInfo*);
+	Image* MaximumImages(const(Image)*, ExceptionInfo*);
+	Image* MinimumImages(const(Image)*, ExceptionInfo*);
 	Image* MosaicImages(Image*, ExceptionInfo*);
 	Image* PopImageList(Image**);
-	Image* RecolorImage(const Image*, const size_t, const double*, ExceptionInfo*);
+	Image* RecolorImage(const(Image)*, const size_t, const(double)*, ExceptionInfo*);
 	Image* ShiftImageList(Image**);
-	Image* SpliceImageList(Image*, const ssize_t, const size_t, const Image*, ExceptionInfo*);
-	Image* ZoomImage(const Image*, const size_t, const size_t, ExceptionInfo*);
+	Image* SpliceImageList(Image*, const ssize_t, const size_t, const(Image)*, ExceptionInfo*);
+	Image* ZoomImage(const(Image)*, const size_t, const size_t, ExceptionInfo*);
 
 	IndexPacket* GetCacheViewIndexes(CacheView*);
-	IndexPacket* GetIndexes(const Image*);
+	IndexPacket* GetIndexes(const(Image)*);
 	IndexPacket  ValidateColormapIndex(Image*, const size_t);
 
-	int GetImageGeometry(Image*, const char*, const uint, RectangleInfo*);
-	int ParseImageGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*);
+	int GetImageGeometry(Image*, const(char)*, const uint, RectangleInfo*);
+	int ParseImageGeometry(const(char)*, ssize_t*, ssize_t*, size_t*, size_t*);
 
-	ssize_t GetImageListIndex(const Image*);
-	ssize_t SetMagickRegistry(const RegistryType, const void*, const size_t, ExceptionInfo*);
+	ssize_t GetImageListIndex(const(Image)*);
+	ssize_t SetMagickRegistry(const RegistryType, const(void)*, const size_t, ExceptionInfo*);
 
-	MagickBooleanType AcquireOneCacheViewPixel(const CacheView*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
-	MagickBooleanType AcquireOneCacheViewVirtualPixel(const CacheView*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
-	MagickBooleanType AffinityImage(const QuantizeInfo*, Image*, const Image*);
-	MagickBooleanType AffinityImages(const QuantizeInfo*, Image*, const Image*);
+	MagickBooleanType AcquireOneCacheViewPixel(const(CacheView)*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType AcquireOneCacheViewVirtualPixel(const(CacheView)*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType AffinityImage(const(QuantizeInfo)*, Image*, const(Image)*);
+	MagickBooleanType AffinityImages(const(QuantizeInfo)*, Image*, const(Image)*);
 	MagickBooleanType AllocateImageColormap(Image*, const size_t);
-	MagickBooleanType ClipPathImage(Image*, const char*, const MagickBooleanType);
-	MagickBooleanType CloneImageAttributes(Image*, const Image*);
-	MagickBooleanType ColorFloodfillImage(Image*, const DrawInfo*, const PixelPacket, const ssize_t, const ssize_t, const PaintMethod);
-	MagickBooleanType DeleteImageAttribute(Image*, const char*);
+	MagickBooleanType ClipPathImage(Image*, const(char)*, const MagickBooleanType);
+	MagickBooleanType CloneImageAttributes(Image*, const(Image)*);
+	MagickBooleanType ColorFloodfillImage(Image*, const(DrawInfo)*, const PixelPacket, const ssize_t, const ssize_t, const PaintMethod);
+	MagickBooleanType DeleteImageAttribute(Image*, const(char)*);
 	MagickBooleanType DeleteMagickRegistry(const ssize_t);
 	MagickBooleanType DescribeImage(Image*, FILE*, const MagickBooleanType);
-	MagickBooleanType FormatImageAttribute(Image*, const char*, const char*, ...);
-	MagickBooleanType FormatImageAttributeList(Image*, const char*, const char*, va_list);
-	MagickBooleanType FuzzyColorCompare(const Image*, const PixelPacket*, const PixelPacket*);
-	MagickBooleanType FuzzyOpacityCompare(const Image*, const PixelPacket*, const PixelPacket*);
-	MagickBooleanType LevelImageColors(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType);
-	MagickBooleanType MagickMonitor(const char*, const MagickOffsetType, const MagickSizeType, void*);
-	MagickBooleanType MapImage(Image*, const Image*, const MagickBooleanType);
-	MagickBooleanType MapImages(Image*, const Image*, const MagickBooleanType);
+	MagickBooleanType FormatImageAttribute(Image*, const(char)*, const(char)*, ...);
+	MagickBooleanType FormatImageAttributeList(Image*, const(char)*, const(char)*, va_list);
+	MagickBooleanType FuzzyColorCompare(const(Image)*, const(PixelPacket)*, const(PixelPacket)*);
+	MagickBooleanType FuzzyOpacityCompare(const(Image)*, const(PixelPacket)*, const(PixelPacket)*);
+	MagickBooleanType LevelImageColors(Image*, const ChannelType, const(MagickPixelPacket)*, const(MagickPixelPacket)*, const MagickBooleanType);
+	MagickBooleanType MagickMonitor(const(char)*, const MagickOffsetType, const MagickSizeType, void*);
+	MagickBooleanType MapImage(Image*, const(Image)*, const MagickBooleanType);
+	MagickBooleanType MapImages(Image*, const(Image)*, const MagickBooleanType);
 	MagickBooleanType MatteFloodfillImage(Image*, const PixelPacket, const Quantum, const ssize_t, const ssize_t, const PaintMethod);
 	MagickBooleanType OpaqueImage(Image*, const PixelPacket, const PixelPacket);
-	MagickBooleanType PaintFloodfillImage(Image*, const ChannelType, const MagickPixelPacket*, const ssize_t, const ssize_t, const DrawInfo*, const PaintMethod);
-	MagickBooleanType PaintOpaqueImage(Image*, const MagickPixelPacket*, const MagickPixelPacket*);
-	MagickBooleanType PaintOpaqueImageChannel(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*);
-	MagickBooleanType PaintTransparentImage(Image*, const MagickPixelPacket*, const Quantum);
+	MagickBooleanType PaintFloodfillImage(Image*, const ChannelType, const(MagickPixelPacket)*, const ssize_t, const ssize_t, const(DrawInfo)*, const PaintMethod);
+	MagickBooleanType PaintOpaqueImage(Image*, const(MagickPixelPacket)*, const(MagickPixelPacket)*);
+	MagickBooleanType PaintOpaqueImageChannel(Image*, const ChannelType, const(MagickPixelPacket)*, const(MagickPixelPacket)*);
+	MagickBooleanType PaintTransparentImage(Image*, const(MagickPixelPacket)*, const Quantum);
 	MagickBooleanType SetExceptionInfo(ExceptionInfo*, ExceptionType);
-	MagickBooleanType SetImageAttribute(Image*, const char*, const char*);
+	MagickBooleanType SetImageAttribute(Image*, const(char)*, const(char)*);
 	MagickBooleanType SyncCacheViewPixels(CacheView*);
 	MagickBooleanType SyncImagePixels(Image*);
 	MagickBooleanType TransparentImage(Image*, const PixelPacket, const Quantum);
 
-	MagickPixelPacket AcquireOneMagickPixel(const Image*, const ssize_t, const ssize_t, ExceptionInfo*);
+	MagickPixelPacket AcquireOneMagickPixel(const(Image)*, const ssize_t, const ssize_t, ExceptionInfo*);
 
 	MonitorHandler GetMonitorHandler();
 	MonitorHandler SetMonitorHandler(MonitorHandler);
 
 	MagickOffsetType SizeBlob(Image* image);
 
-	MagickPixelPacket InterpolatePixelColor(const Image*, CacheView*, const InterpolatePixelMethod, const double, const double, ExceptionInfo*);
+	MagickPixelPacket InterpolatePixelColor(const(Image)*, CacheView*, const InterpolatePixelMethod, const double, const double, ExceptionInfo*);
 
-	MagickStatusType ParseSizeGeometry(const Image*, const char*, RectangleInfo*);
+	MagickStatusType ParseSizeGeometry(const(Image)*, const(char)*, RectangleInfo*);
 
-	PixelPacket  AcquireOnePixel(const Image*, const ssize_t, const ssize_t, ExceptionInfo*);
-	PixelPacket  AcquireOneVirtualPixel(const Image*, const VirtualPixelMethod, const ssize_t, const ssize_t, ExceptionInfo*);
+	PixelPacket  AcquireOnePixel(const(Image)*, const ssize_t, const ssize_t, ExceptionInfo*);
+	PixelPacket  AcquireOneVirtualPixel(const(Image)*, const VirtualPixelMethod, const ssize_t, const ssize_t, ExceptionInfo*);
 	PixelPacket* GetCacheView(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t);
 	PixelPacket* GetCacheViewPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t);
 	PixelPacket* GetImagePixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t);
 	PixelPacket  GetOnePixel(Image*, const ssize_t, const ssize_t);
-	PixelPacket* GetPixels(const Image*);
+	PixelPacket* GetPixels(const(Image)*);
 	PixelPacket* SetCacheViewPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t);
 	PixelPacket* SetImagePixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t);
 
-	size_t GetImageListSize(const Image*);
+	size_t GetImageListSize(const(Image)*);
 	size_t PopImagePixels(Image*, const QuantumType, ubyte*);
-	size_t PushImagePixels(Image*, const QuantumType, const byte*);
+	size_t PushImagePixels(Image*, const QuantumType, const(byte)*);
 
 	uint ChannelImage(Image*, const ChannelType);
-	uint ChannelThresholdImage(Image*, const char*);
-	uint DispatchImage(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, const char*, const StorageType, void*, ExceptionInfo*);
-	uint FuzzyColorMatch(const PixelPacket*, const PixelPacket*, const double);
-	uint GetNumberScenes(const Image*);
-	uint GetMagickGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*);
-	uint IsSubimage(const char*, const uint);
-	uint PushImageList(Image**, const Image*, ExceptionInfo*);
+	uint ChannelThresholdImage(Image*, const(char)*);
+	uint DispatchImage(const(Image)*, const ssize_t, const ssize_t, const size_t, const size_t, const(char)*, const StorageType, void*, ExceptionInfo*);
+	uint FuzzyColorMatch(const(PixelPacket)*, const(PixelPacket)*, const double);
+	uint GetNumberScenes(const(Image)*);
+	uint GetMagickGeometry(const(char)*, ssize_t*, ssize_t*, size_t*, size_t*);
+	uint IsSubimage(const(char)*, const uint);
+	uint PushImageList(Image**, const(Image)*, ExceptionInfo*);
 	uint QuantizationError(Image*);
-	uint RandomChannelThresholdImage(Image*, const char*, const char*, ExceptionInfo*);
-	uint SetImageList(Image**, const Image*, const ssize_t, ExceptionInfo*);
+	uint RandomChannelThresholdImage(Image*, const(char)*, const(char)*, ExceptionInfo*);
+	uint SetImageList(Image**, const(Image)*, const ssize_t, ExceptionInfo*);
 	uint TransformColorspace(Image*, const ColorspaceType);
 	uint ThresholdImage(Image*, const double);
-	uint ThresholdImageChannel(Image*, const char*);
-	uint UnshiftImageList(Image**, const Image*, ExceptionInfo*);
+	uint ThresholdImageChannel(Image*, const(char)*);
+	uint UnshiftImageList(Image**, const(Image)*, ExceptionInfo*);
 
 	void* AcquireMemory(const size_t);
-	void  AllocateNextImage(const ImageInfo*, Image*);
-	void* CloneMemory(void*, const void*, const size_t);
+	void  AllocateNextImage(const(ImageInfo)*, Image*);
+	void* CloneMemory(void*, const(void)*, const size_t);
 	void  DestroyImageAttributes(Image*);
 	void  DestroyImages(Image*);
 	void  DestroyMagick();
 	void  DestroyMagickRegistry();
-	void* GetConfigureBlob(const char*, char*, size_t*, ExceptionInfo*);
+	void* GetConfigureBlob(const(char)*, char*, size_t*, ExceptionInfo*);
 	void* GetMagickRegistry(const ssize_t, RegistryType*, size_t*, ExceptionInfo*);
 	void  IdentityAffine(AffineMatrix*);
 	void  LiberateMemory(void**);
 	void  LiberateSemaphoreInfo(SemaphoreInfo**);
-	void  FormatString(char*, const char*, ...);
-	void  FormatStringList(char*, const char*, va_list);
+	void  FormatString(char*, const(char)*, ...);
+	void  FormatStringList(char*, const(char)*, va_list);
 	void  HSLTransform(const double, const double, const double, Quantum*, Quantum*, Quantum*);
-	void  InitializeMagick(const char*);
-	void  MagickIncarnate(const char*);
+	void  InitializeMagick(const(char)*);
+	void  MagickIncarnate(const(char)*);
 	void  ReacquireMemory(void**, const size_t);
-	void  ResetImageAttributeIterator(const Image*);
+	void  ResetImageAttributeIterator(const(Image)*);
 	void  SetCacheThreshold(const size_t);
 	void  SetImage(Image*, const Quantum);
 	void  Strip(char*);
diff --git a/dmagick/c/display.d b/dmagick/c/display.d
index 3b11356..812fcaf 100644
--- a/dmagick/c/display.d
+++ b/dmagick/c/display.d
@@ -6,6 +6,6 @@ import dmagick.c.magickType;
 
 extern(C)
 {
-	MagickBooleanType DisplayImages(const ImageInfo*, Image*);
-	MagickBooleanType RemoteDisplayCommand(const ImageInfo*, const char*, const char*, ExceptionInfo*);
+	MagickBooleanType DisplayImages(const(ImageInfo)*, Image*);
+	MagickBooleanType RemoteDisplayCommand(const(ImageInfo)*, const(char)*, const(char)*, ExceptionInfo*);
 }
diff --git a/dmagick/c/distort.d b/dmagick/c/distort.d
index bb32224..4c15839 100644
--- a/dmagick/c/distort.d
+++ b/dmagick/c/distort.d
@@ -38,6 +38,6 @@ extern(C)
 		VoronoiColorInterpolate =     DistortImageMethod.SentinelDistortion
 	}
 
-	Image* DistortImage(const Image*, const DistortImageMethod, const size_t, const double*, MagickBooleanType, ExceptionInfo* exception);
-	Image* SparseColorImage(const Image*, const ChannelType, const SparseColorMethod, const size_t, const double*, ExceptionInfo*);
+	Image* DistortImage(const(Image)*, const DistortImageMethod, const size_t, const(double)*, MagickBooleanType, ExceptionInfo* exception);
+	Image* SparseColorImage(const(Image)*, const ChannelType, const SparseColorMethod, const size_t, const(double)*, ExceptionInfo*);
 }
diff --git a/dmagick/c/draw.d b/dmagick/c/draw.d
index 7032abe..9d2d8cb 100644
--- a/dmagick/c/draw.d
+++ b/dmagick/c/draw.d
@@ -354,16 +354,16 @@ extern(C)
 	}
 
 	DrawInfo* AcquireDrawInfo();
-	DrawInfo* CloneDrawInfo(const ImageInfo*, const DrawInfo*);
+	DrawInfo* CloneDrawInfo(const(ImageInfo)*, const(DrawInfo)*);
 	DrawInfo* DestroyDrawInfo(DrawInfo*);
 
-	MagickBooleanType DrawAffineImage(Image*, const Image*, const AffineMatrix*);
-	MagickBooleanType DrawClipPath(Image*, const DrawInfo*, const char*);
-	MagickBooleanType DrawGradientImage(Image*, const DrawInfo*);
-	MagickBooleanType DrawImage(Image*, const DrawInfo*);
-	MagickBooleanType DrawPatternPath(Image*, const DrawInfo*, const char*, Image**);
-	MagickBooleanType DrawPrimitive(Image*, const DrawInfo*, const PrimitiveInfo*);
+	MagickBooleanType DrawAffineImage(Image*, const(Image)*, const(AffineMatrix)*);
+	MagickBooleanType DrawClipPath(Image*, const(DrawInfo)*, const(char)*);
+	MagickBooleanType DrawGradientImage(Image*, const(DrawInfo)*);
+	MagickBooleanType DrawImage(Image*, const(DrawInfo)*);
+	MagickBooleanType DrawPatternPath(Image*, const(DrawInfo)*, const(char)*, Image**);
+	MagickBooleanType DrawPrimitive(Image*, const(DrawInfo)*, const(PrimitiveInfo)*);
 
 	void GetAffineMatrix(AffineMatrix*);
-	void GetDrawInfo(const ImageInfo*, DrawInfo*);
+	void GetDrawInfo(const(ImageInfo)*, DrawInfo*);
 }
diff --git a/dmagick/c/effect.d b/dmagick/c/effect.d
index b229a8f..b79cf75 100644
--- a/dmagick/c/effect.d
+++ b/dmagick/c/effect.d
@@ -41,34 +41,34 @@ extern(C)
 		JPEGPreview
 	}
 
-	Image* AdaptiveBlurImage(const Image*, const double, const double, ExceptionInfo*);
-	Image* AdaptiveBlurImageChannel(const Image*, const ChannelType, const double, const double, ExceptionInfo*);
-	Image* AdaptiveSharpenImage(const Image*, const double, const double, ExceptionInfo*);
-	Image* AdaptiveSharpenImageChannel(const Image*, const ChannelType, const double, const double, ExceptionInfo*);
-	Image* BlurImage(const Image*, const double, const double, ExceptionInfo*);
-	Image* BlurImageChannel(const Image*, const ChannelType, const double, const double, ExceptionInfo*);
-	Image* ConvolveImage(const Image*, const size_t, const double*, ExceptionInfo*);
-	Image* ConvolveImageChannel(const Image*, const ChannelType, const size_t, const double*, ExceptionInfo*);
-	Image* DespeckleImage(const Image*, ExceptionInfo*);
-	Image* EdgeImage(const Image*, const double, ExceptionInfo*);
-	Image* EmbossImage(const Image*, const double, const double, ExceptionInfo*);
-	Image* FilterImage(const Image*, const KernelInfo*, ExceptionInfo*);
-	Image* FilterImageChannel(const Image*, const ChannelType, const KernelInfo*, ExceptionInfo*);
-	Image* GaussianBlurImage(const Image*, const double, const double, ExceptionInfo*);
-	Image* GaussianBlurImageChannel(const Image*, const ChannelType, const double, const double, ExceptionInfo*);
-	Image* MedianFilterImage(const Image*, const double, ExceptionInfo*);
-	Image* MotionBlurImage(const Image*, const double, const double, const double, ExceptionInfo*);
-	Image* MotionBlurImageChannel(const Image*, const ChannelType, const double, const double, const double, ExceptionInfo*);
-	Image* PreviewImage(const Image*, const PreviewType, ExceptionInfo*);
-	Image* RadialBlurImage(const Image*, const double, ExceptionInfo*);
-	Image* RadialBlurImageChannel(const Image*, const ChannelType, const double, ExceptionInfo*);
-	Image* ReduceNoiseImage(const Image*, const double, ExceptionInfo*);
-	Image* SelectiveBlurImage(const Image*, const double, const double, const double, ExceptionInfo*);
-	Image* SelectiveBlurImageChannel(const Image*, const ChannelType, const double, const double, const double, ExceptionInfo*);
-	Image* ShadeImage(const Image*, const MagickBooleanType, const double, const double, ExceptionInfo*);
-	Image* SharpenImage(const Image*, const double, const double, ExceptionInfo*);
-	Image* SharpenImageChannel(const Image*, const ChannelType ,const double, const double, ExceptionInfo*);
-	Image* SpreadImage(const Image*, const double, ExceptionInfo*);
-	Image* UnsharpMaskImage(const Image*, const double, const double, const double, const double, ExceptionInfo*);
-	Image* UnsharpMaskImageChannel(const Image*, const ChannelType, const double, const double, const double, const double, ExceptionInfo*);
+	Image* AdaptiveBlurImage(const(Image)*, const double, const double, ExceptionInfo*);
+	Image* AdaptiveBlurImageChannel(const(Image)*, const ChannelType, const double, const double, ExceptionInfo*);
+	Image* AdaptiveSharpenImage(const(Image)*, const double, const double, ExceptionInfo*);
+	Image* AdaptiveSharpenImageChannel(const(Image)*, const ChannelType, const double, const double, ExceptionInfo*);
+	Image* BlurImage(const(Image)*, const double, const double, ExceptionInfo*);
+	Image* BlurImageChannel(const(Image)*, const ChannelType, const double, const double, ExceptionInfo*);
+	Image* ConvolveImage(const(Image)*, const size_t, const(double)*, ExceptionInfo*);
+	Image* ConvolveImageChannel(const(Image)*, const ChannelType, const size_t, const(double)*, ExceptionInfo*);
+	Image* DespeckleImage(const(Image)*, ExceptionInfo*);
+	Image* EdgeImage(const(Image)*, const double, ExceptionInfo*);
+	Image* EmbossImage(const(Image)*, const double, const double, ExceptionInfo*);
+	Image* FilterImage(const(Image)*, const(KernelInfo)*, ExceptionInfo*);
+	Image* FilterImageChannel(const(Image)*, const ChannelType, const(KernelInfo)*, ExceptionInfo*);
+	Image* GaussianBlurImage(const(Image)*, const double, const double, ExceptionInfo*);
+	Image* GaussianBlurImageChannel(const(Image)*, const ChannelType, const double, const double, ExceptionInfo*);
+	Image* MedianFilterImage(const(Image)*, const double, ExceptionInfo*);
+	Image* MotionBlurImage(const(Image)*, const double, const double, const double, ExceptionInfo*);
+	Image* MotionBlurImageChannel(const(Image)*, const ChannelType, const double, const double, const double, ExceptionInfo*);
+	Image* PreviewImage(const(Image)*, const PreviewType, ExceptionInfo*);
+	Image* RadialBlurImage(const(Image)*, const double, ExceptionInfo*);
+	Image* RadialBlurImageChannel(const(Image)*, const ChannelType, const double, ExceptionInfo*);
+	Image* ReduceNoiseImage(const(Image)*, const double, ExceptionInfo*);
+	Image* SelectiveBlurImage(const(Image)*, const double, const double, const double, ExceptionInfo*);
+	Image* SelectiveBlurImageChannel(const(Image)*, const ChannelType, const double, const double, const double, ExceptionInfo*);
+	Image* ShadeImage(const(Image)*, const MagickBooleanType, const double, const double, ExceptionInfo*);
+	Image* SharpenImage(const(Image)*, const double, const double, ExceptionInfo*);
+	Image* SharpenImageChannel(const(Image)*, const ChannelType ,const double, const double, ExceptionInfo*);
+	Image* SpreadImage(const(Image)*, const double, ExceptionInfo*);
+	Image* UnsharpMaskImage(const(Image)*, const double, const double, const double, const double, ExceptionInfo*);
+	Image* UnsharpMaskImageChannel(const(Image)*, const ChannelType, const double, const double, const double, const double, ExceptionInfo*);
 }
diff --git a/dmagick/c/enhance.d b/dmagick/c/enhance.d
index 6138e2c..722a3ca 100644
--- a/dmagick/c/enhance.d
+++ b/dmagick/c/enhance.d
@@ -13,32 +13,32 @@ extern(C)
 	MagickBooleanType AutoLevelImageChannel(Image*, const ChannelType);
 	MagickBooleanType BrightnessContrastImage(Image*, const double, const double);
 	MagickBooleanType BrightnessContrastImageChannel(Image*, const ChannelType, const double, const double);
-	MagickBooleanType ClutImage(Image*, const Image*);
-	MagickBooleanType ClutImageChannel(Image*, const ChannelType, const Image*);
-	MagickBooleanType ColorDecisionListImage(Image*, const char*);
+	MagickBooleanType ClutImage(Image*, const(Image)*);
+	MagickBooleanType ClutImageChannel(Image*, const ChannelType, const(Image)*);
+	MagickBooleanType ColorDecisionListImage(Image*, const(char)*);
 	MagickBooleanType ContrastImage(Image*, const MagickBooleanType);
-	MagickBooleanType ContrastStretchImage(Image*, const char*);
+	MagickBooleanType ContrastStretchImage(Image*, const(char)*);
 	MagickBooleanType ContrastStretchImageChannel(Image*, const ChannelType, const double, const double);
 	MagickBooleanType EqualizeImage(Image* image);
 	MagickBooleanType EqualizeImageChannel(Image* image, const ChannelType);
-	MagickBooleanType GammaImage(Image*, const char*);
+	MagickBooleanType GammaImage(Image*, const(char)*);
 	MagickBooleanType GammaImageChannel(Image*, const ChannelType, const double);
-	MagickBooleanType HaldClutImage(Image*, const Image*);
-	MagickBooleanType HaldClutImageChannel(Image*, const ChannelType, const Image*);
-	MagickBooleanType LevelImage(Image*, const char*);
+	MagickBooleanType HaldClutImage(Image*, const(Image)*);
+	MagickBooleanType HaldClutImageChannel(Image*, const ChannelType, const(Image)*);
+	MagickBooleanType LevelImage(Image*, const(char)*);
 	MagickBooleanType LevelImageChannel(Image*, const ChannelType, const double, const double, const double);
 	MagickBooleanType LevelizeImage(Image*, const double, const double, const double);
 	MagickBooleanType LevelizeImageChannel(Image*, const ChannelType, const double, const double, const double);
-	MagickBooleanType LevelColorsImage(Image*, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType);
-	MagickBooleanType LevelColorsImageChannel(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType);
+	MagickBooleanType LevelColorsImage(Image*, const(MagickPixelPacket)*, const(MagickPixelPacket)*, const MagickBooleanType);
+	MagickBooleanType LevelColorsImageChannel(Image*, const ChannelType, const(MagickPixelPacket)*, const(MagickPixelPacket)*, const MagickBooleanType);
 	MagickBooleanType LinearStretchImage(Image*, const double, const double);
-	MagickBooleanType ModulateImage(Image*, const char*);
+	MagickBooleanType ModulateImage(Image*, const(char)*);
 	MagickBooleanType NegateImage(Image*, const MagickBooleanType);
 	MagickBooleanType NegateImageChannel(Image*, const ChannelType, const MagickBooleanType);
 	MagickBooleanType NormalizeImage(Image*);
 	MagickBooleanType NormalizeImageChannel(Image*, const ChannelType);
-	MagickBooleanType SigmoidalContrastImage(Image*, const MagickBooleanType, const char*);
+	MagickBooleanType SigmoidalContrastImage(Image*, const MagickBooleanType, const(char)*);
 	MagickBooleanType SigmoidalContrastImageChannel(Image*, const ChannelType, const MagickBooleanType, const double, const double);
 
-	Image* EnhanceImage(const Image*, ExceptionInfo*);
+	Image* EnhanceImage(const(Image)*, ExceptionInfo*);
 }
diff --git a/dmagick/c/exception.d b/dmagick/c/exception.d
index 9236455..57bdb13 100644
--- a/dmagick/c/exception.d
+++ b/dmagick/c/exception.d
@@ -106,13 +106,13 @@ extern(C)
 			signature;
 	}
 
-	alias void function(const ExceptionType, const char*, const char*) ErrorHandler;
-	alias void function(const ExceptionType, const char*, const char*) FatalErrorHandler;
-	alias void function(const ExceptionType, const char*, const char*) WarningHandler;
+	alias void function(const ExceptionType, const(char)*, const(char)*) ErrorHandler;
+	alias void function(const ExceptionType, const(char)*, const(char)*) FatalErrorHandler;
+	alias void function(const ExceptionType, const(char)*, const(char)*) WarningHandler;
 
 	char* GetExceptionMessage(const int);
 
-	const(char*) GetLocaleExceptionMessage(const ExceptionType, const char*);
+	const(char*) GetLocaleExceptionMessage(const ExceptionType, const(char)*);
 
 	ErrorHandler SetErrorHandler(ErrorHandler);
 
@@ -121,17 +121,17 @@ extern(C)
 
 	FatalErrorHandler SetFatalErrorHandler(FatalErrorHandler);
 
-	MagickBooleanType ThrowException(ExceptionInfo*, const ExceptionType, const char*, const char*);
-	MagickBooleanType ThrowMagickException(ExceptionInfo*, const char*, const char*, const size_t, const ExceptionType, const char*, const char*, ...);
-	MagickBooleanType ThrowMagickExceptionList(ExceptionInfo*, const char*, const char*, const size_t, const ExceptionType, const char*, const char*, va_list);
+	MagickBooleanType ThrowException(ExceptionInfo*, const ExceptionType, const(char)*, const(char)*);
+	MagickBooleanType ThrowMagickException(ExceptionInfo*, const(char)*, const(char)*, const size_t, const ExceptionType, const(char)*, const(char)*, ...);
+	MagickBooleanType ThrowMagickExceptionList(ExceptionInfo*, const(char)*, const(char)*, const size_t, const ExceptionType, const(char)*, const(char)*, va_list);
 
 	void CatchException(ExceptionInfo*);
 	void ClearMagickException(ExceptionInfo*);
 	void GetExceptionInfo(ExceptionInfo*);
-	void InheritException(ExceptionInfo*, const ExceptionInfo*);
-	void MagickError(const ExceptionType, const char*, const char*);
-	void MagickFatalError(const ExceptionType, const char*, const char*);
-	void MagickWarning(const ExceptionType, const char*, const char*);
+	void InheritException(ExceptionInfo*, const(ExceptionInfo)*);
+	void MagickError(const ExceptionType, const(char)*, const(char)*);
+	void MagickFatalError(const ExceptionType, const(char)*, const(char)*);
+	void MagickWarning(const ExceptionType, const(char)*, const(char)*);
 
 	WarningHandler SetWarningHandler(WarningHandler);
 }
diff --git a/dmagick/c/feature.d b/dmagick/c/feature.d
index 1ebef79..a877e49 100644
--- a/dmagick/c/feature.d
+++ b/dmagick/c/feature.d
@@ -24,5 +24,5 @@ extern(C)
 			maximum_correlation_coefficient;
 	}
 
-	ChannelFeatures* GetImageChannelFeatures(const Image*, const size_t, ExceptionInfo*);
+	ChannelFeatures* GetImageChannelFeatures(const(Image)*, const size_t, ExceptionInfo*);
 }
diff --git a/dmagick/c/fourier.d b/dmagick/c/fourier.d
index d866dac..553b71e 100644
--- a/dmagick/c/fourier.d
+++ b/dmagick/c/fourier.d
@@ -6,6 +6,6 @@ import dmagick.c.magickType;
 
 extern(C)
 {
-	Image* ForwardFourierTransformImage(const Image*, const MagickBooleanType, ExceptionInfo*);
-	Image* InverseFourierTransformImage(const Image*, const Image*, const MagickBooleanType, ExceptionInfo*);
+	Image* ForwardFourierTransformImage(const(Image)*, const MagickBooleanType, ExceptionInfo*);
+	Image* InverseFourierTransformImage(const(Image)*, const(Image)*, const MagickBooleanType, ExceptionInfo*);
 }
diff --git a/dmagick/c/fx.d b/dmagick/c/fx.d
index b02a49c..c55f9d0 100644
--- a/dmagick/c/fx.d
+++ b/dmagick/c/fx.d
@@ -23,28 +23,28 @@ extern(C)
 		RandomNoise
 	}
 
-	Image* AddNoiseImage(const Image*, const NoiseType, ExceptionInfo*);
-	Image* AddNoiseImageChannel(const Image*, const ChannelType, const NoiseType, ExceptionInfo*);
-	Image* BlueShiftImage(const Image*, const double, ExceptionInfo*);
-	Image* CharcoalImage(const Image*, const double, const double, ExceptionInfo*);
-	Image* ColorizeImage(const Image*, const char*, const PixelPacket, ExceptionInfo*);
-	Image* ColorMatrixImage(const Image*, const KernelInfo* kernel, ExceptionInfo*);
-	Image* FxImage(const Image*, const char*, ExceptionInfo*);
-	Image* FxImageChannel(const Image*, const ChannelType, const char*, ExceptionInfo*);
-	Image* ImplodeImage(const Image*, const double, ExceptionInfo*);
-	Image* MorphImages(const Image*, const size_t, ExceptionInfo*);
-	Image* PolaroidImage(const Image*, const DrawInfo*, const double, ExceptionInfo*);
-	Image* SepiaToneImage(const Image*, const double, ExceptionInfo*);
-	Image* ShadowImage(const Image*, const double, const double, const ssize_t, const ssize_t, ExceptionInfo*);
-	Image* SketchImage(const Image*, const double, const double, const double, ExceptionInfo*);
-	Image* SteganoImage(const Image*, const Image*, ExceptionInfo*);
-	Image* StereoImage(const Image*, const Image*, ExceptionInfo*);
-	Image* StereoAnaglyphImage(const Image*, const Image*, const ssize_t, const ssize_t, ExceptionInfo*);
-	Image* SwirlImage(const Image*, double, ExceptionInfo*);
-	Image* TintImage(const Image*, const char*, const PixelPacket, ExceptionInfo*);
-	Image* VignetteImage(const Image*, const double, const double, const ssize_t, const ssize_t, ExceptionInfo*);
-	Image* WaveImage(const Image*, const double, const double, ExceptionInfo*);
+	Image* AddNoiseImage(const(Image)*, const NoiseType, ExceptionInfo*);
+	Image* AddNoiseImageChannel(const(Image)*, const ChannelType, const NoiseType, ExceptionInfo*);
+	Image* BlueShiftImage(const(Image)*, const double, ExceptionInfo*);
+	Image* CharcoalImage(const(Image)*, const double, const double, ExceptionInfo*);
+	Image* ColorizeImage(const(Image)*, const(char)*, const PixelPacket, ExceptionInfo*);
+	Image* ColorMatrixImage(const(Image)*, const(KernelInfo)* kernel, ExceptionInfo*);
+	Image* FxImage(const(Image)*, const(char)*, ExceptionInfo*);
+	Image* FxImageChannel(const(Image)*, const ChannelType, const(char)*, ExceptionInfo*);
+	Image* ImplodeImage(const(Image)*, const double, ExceptionInfo*);
+	Image* MorphImages(const(Image)*, const size_t, ExceptionInfo*);
+	Image* PolaroidImage(const(Image)*, const(DrawInfo)*, const double, ExceptionInfo*);
+	Image* SepiaToneImage(const(Image)*, const double, ExceptionInfo*);
+	Image* ShadowImage(const(Image)*, const double, const double, const ssize_t, const ssize_t, ExceptionInfo*);
+	Image* SketchImage(const(Image)*, const double, const double, const double, ExceptionInfo*);
+	Image* SteganoImage(const(Image)*, const(Image)*, ExceptionInfo*);
+	Image* StereoImage(const(Image)*, const(Image)*, ExceptionInfo*);
+	Image* StereoAnaglyphImage(const(Image)*, const(Image)*, const ssize_t, const ssize_t, ExceptionInfo*);
+	Image* SwirlImage(const(Image)*, double, ExceptionInfo*);
+	Image* TintImage(const(Image)*, const(char)*, const PixelPacket, ExceptionInfo*);
+	Image* VignetteImage(const(Image)*, const double, const double, const ssize_t, const ssize_t, ExceptionInfo*);
+	Image* WaveImage(const(Image)*, const double, const double, ExceptionInfo*);
 
-	MagickBooleanType PlasmaImage(Image*, const SegmentInfo*, size_t, size_t);
+	MagickBooleanType PlasmaImage(Image*, const(SegmentInfo)*, size_t, size_t);
 	MagickBooleanType SolarizeImage(Image*, const double);
 }
diff --git a/dmagick/c/gem.d b/dmagick/c/gem.d
index 1833005..43bcad4 100644
--- a/dmagick/c/gem.d
+++ b/dmagick/c/gem.d
@@ -7,7 +7,7 @@ import dmagick.c.random;
 
 extern(C)
 {
-	double ExpandAffine(const AffineMatrix*);
+	double ExpandAffine(const(AffineMatrix)*);
 	double GenerateDifferentialNoise(RandomInfo*, const Quantum, const NoiseType, const MagickRealType);
 
 	size_t GetOptimalKernelWidth(const double, const double);
diff --git a/dmagick/c/geometry.d b/dmagick/c/geometry.d
index 126944e..9722ca3 100644
--- a/dmagick/c/geometry.d
+++ b/dmagick/c/geometry.d
@@ -99,21 +99,21 @@ extern(C)
 			y;
 	}
 
-	char* GetPageGeometry(const char*);
+	char* GetPageGeometry(const(char)*);
 
-	MagickBooleanType IsGeometry(const char*);
-	MagickBooleanType IsSceneGeometry(const char*, const MagickBooleanType);
+	MagickBooleanType IsGeometry(const(char)*);
+	MagickBooleanType IsSceneGeometry(const(char)*, const MagickBooleanType);
 
-	MagickStatusType GetGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*);
-	MagickStatusType ParseAbsoluteGeometry(const char*, RectangleInfo*);
-	MagickStatusType ParseAffineGeometry(const char*, AffineMatrix*, ExceptionInfo*);
-	MagickStatusType ParseGeometry(const char*, GeometryInfo*);
-	MagickStatusType ParseGravityGeometry(const Image*, const char*, RectangleInfo*, ExceptionInfo*);
-	MagickStatusType ParseMetaGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*);
-	MagickStatusType ParsePageGeometry(const Image*, const char*, RectangleInfo*, ExceptionInfo*);
-	MagickStatusType ParseRegionGeometry(const Image*, const char*, RectangleInfo*, ExceptionInfo*);
+	MagickStatusType GetGeometry(const(char)*, ssize_t*, ssize_t*, size_t*, size_t*);
+	MagickStatusType ParseAbsoluteGeometry(const(char)*, RectangleInfo*);
+	MagickStatusType ParseAffineGeometry(const(char)*, AffineMatrix*, ExceptionInfo*);
+	MagickStatusType ParseGeometry(const(char)*, GeometryInfo*);
+	MagickStatusType ParseGravityGeometry(const(Image)*, const(char)*, RectangleInfo*, ExceptionInfo*);
+	MagickStatusType ParseMetaGeometry(const(char)*, ssize_t*, ssize_t*, size_t*, size_t*);
+	MagickStatusType ParsePageGeometry(const(Image)*, const(char)*, RectangleInfo*, ExceptionInfo*);
+	MagickStatusType ParseRegionGeometry(const(Image)*, const(char)*, RectangleInfo*, ExceptionInfo*);
 
 	void GravityAdjustGeometry(const size_t, const size_t, const GravityType, RectangleInfo*);
-	void SetGeometry(const Image*, RectangleInfo*);
+	void SetGeometry(const(Image)*, RectangleInfo*);
 	void SetGeometryInfo(GeometryInfo*);
 }
diff --git a/dmagick/c/hashmap.d b/dmagick/c/hashmap.d
index a0bcfb2..7c0928f 100644
--- a/dmagick/c/hashmap.d
+++ b/dmagick/c/hashmap.d
@@ -9,38 +9,38 @@ extern(C)
 	struct LinkedListInfo {}
 
 	HashmapInfo* DestroyHashmap(HashmapInfo*);
-	HashmapInfo* NewHashmap(const size_t, size_t function(const void*),
-			MagickBooleanType function(const void*, const void*), void* function(void*), void* function(void*));
+	HashmapInfo* NewHashmap(const size_t, size_t function(const(void)*),
+			MagickBooleanType function(const(void)*, const(void)*), void* function(void*), void* function(void*));
 
 	LinkedListInfo* DestroyLinkedList(LinkedListInfo*, void* function(void*));
 	LinkedListInfo* NewLinkedList(const size_t);
 
-	MagickBooleanType AppendValueToLinkedList(LinkedListInfo*, const void*);
-	MagickBooleanType CompareHashmapString(const void*, const void*);
-	MagickBooleanType CompareHashmapStringInfo(const void*, const void*);
-	MagickBooleanType InsertValueInLinkedList(LinkedListInfo*, const size_t, const void*);
-	MagickBooleanType InsertValueInSortedLinkedList(LinkedListInfo*, int function(const void*, const void*), void**, const void*);
-	MagickBooleanType IsHashmapEmpty(const HashmapInfo*);
-	MagickBooleanType IsLinkedListEmpty(const LinkedListInfo*);
+	MagickBooleanType AppendValueToLinkedList(LinkedListInfo*, const(void)*);
+	MagickBooleanType CompareHashmapString(const(void)*, const(void)*);
+	MagickBooleanType CompareHashmapStringInfo(const(void)*, const(void)*);
+	MagickBooleanType InsertValueInLinkedList(LinkedListInfo*, const size_t, const(void)*);
+	MagickBooleanType InsertValueInSortedLinkedList(LinkedListInfo*, int function(const(void)*, const(void)*), void**, const(void)*);
+	MagickBooleanType IsHashmapEmpty(const(HashmapInfo)*);
+	MagickBooleanType IsLinkedListEmpty(const(LinkedListInfo)*);
 	MagickBooleanType LinkedListToArray(LinkedListInfo*, void**);
-	MagickBooleanType PutEntryInHashmap(HashmapInfo*, const void*, const void*);
+	MagickBooleanType PutEntryInHashmap(HashmapInfo*, const(void)*, const(void)*);
 
-	size_t GetNumberOfElementsInLinkedList(const LinkedListInfo*);
-	size_t GetNumberOfEntriesInHashmap(const HashmapInfo*);
-	size_t HashPointerType(const void*);
-	size_t HashStringType(const void*);
-	size_t HashStringInfoType(const void*);
+	size_t GetNumberOfElementsInLinkedList(const(LinkedListInfo)*);
+	size_t GetNumberOfEntriesInHashmap(const(HashmapInfo)*);
+	size_t HashPointerType(const(void)*);
+	size_t HashStringType(const(void)*);
+	size_t HashStringInfoType(const(void)*);
 
 	void  ClearLinkedList(LinkedListInfo*, void* function(void*));
 	void* GetLastValueInLinkedList(LinkedListInfo*);
 	void* GetNextKeyInHashmap(HashmapInfo*);
 	void* GetNextValueInHashmap(HashmapInfo*);
 	void* GetNextValueInLinkedList(LinkedListInfo*);
-	void* GetValueFromHashmap(HashmapInfo*, const void*);
+	void* GetValueFromHashmap(HashmapInfo*, const(void)*);
 	void* GetValueFromLinkedList(LinkedListInfo*, const size_t);
-	void* RemoveElementByValueFromLinkedList(LinkedListInfo*, const void*);
+	void* RemoveElementByValueFromLinkedList(LinkedListInfo*, const(void)*);
 	void* RemoveElementFromLinkedList(LinkedListInfo*, const size_t);
-	void* RemoveEntryFromHashmap(HashmapInfo*, const void*);
+	void* RemoveEntryFromHashmap(HashmapInfo*, const(void)*);
 	void* RemoveLastElementFromLinkedList(LinkedListInfo*);
 	void  ResetHashmapIterator(HashmapInfo*);
 	void  ResetLinkedListIterator(LinkedListInfo*);
diff --git a/dmagick/c/histogram.d b/dmagick/c/histogram.d
index 2341186..1722415 100644
--- a/dmagick/c/histogram.d
+++ b/dmagick/c/histogram.d
@@ -21,13 +21,13 @@ extern(C)
 			count;
 	}
 
-	ColorPacket* GetImageHistogram(const Image*, size_t*, ExceptionInfo*);
+	ColorPacket* GetImageHistogram(const(Image)*, size_t*, ExceptionInfo*);
 
-	Image* UniqueImageColors(const Image*, ExceptionInfo*);
+	Image* UniqueImageColors(const(Image)*, ExceptionInfo*);
 
-	MagickBooleanType IsHistogramImage(const Image*, ExceptionInfo*);
-	MagickBooleanType IsPaletteImage(const Image*, ExceptionInfo*);
+	MagickBooleanType IsHistogramImage(const(Image)*, ExceptionInfo*);
+	MagickBooleanType IsPaletteImage(const(Image)*, ExceptionInfo*);
 	MagickBooleanType MinMaxStretchImage(Image*, const ChannelType, const double, const double);
 
-	size_t GetNumberColors(const Image*, FILE*, ExceptionInfo*);
+	size_t GetNumberColors(const(Image)*, FILE*, ExceptionInfo*);
 }
diff --git a/dmagick/c/image.d b/dmagick/c/image.d
index 54adb1e..1425cc6 100644
--- a/dmagick/c/image.d
+++ b/dmagick/c/image.d
@@ -476,61 +476,61 @@ extern(C)
 
 	ExceptionType CatchImageException(Image*);
 
-	FILE* GetImageInfoFile(const ImageInfo*);
+	FILE* GetImageInfoFile(const(ImageInfo)*);
 
-	Image* AcquireImage(const ImageInfo*);
-	Image* AppendImages(const Image*, const MagickBooleanType, ExceptionInfo*);
-	Image* CloneImage(const Image*, const size_t, const size_t, const MagickBooleanType, ExceptionInfo*);
-	Image* CombineImages(const Image*, const ChannelType, ExceptionInfo*);
+	Image* AcquireImage(const(ImageInfo)*);
+	Image* AppendImages(const(Image)*, const MagickBooleanType, ExceptionInfo*);
+	Image* CloneImage(const(Image)*, const size_t, const size_t, const MagickBooleanType, ExceptionInfo*);
+	Image* CombineImages(const(Image)*, const ChannelType, ExceptionInfo*);
 	Image* DestroyImage(Image*);
-	Image* GetImageClipMask(const Image*, ExceptionInfo*);
-	Image* GetImageMask(const Image*, ExceptionInfo*);
-	Image* NewMagickImage(const ImageInfo*, const size_t, const size_t, const MagickPixelPacket*);
+	Image* GetImageClipMask(const(Image)*, ExceptionInfo*);
+	Image* GetImageMask(const(Image)*, ExceptionInfo*);
+	Image* NewMagickImage(const(ImageInfo)*, const size_t, const size_t, const(MagickPixelPacket)*);
 	Image* ReferenceImage(Image*);
-	Image* SeparateImages(const Image*, const ChannelType, ExceptionInfo*);
+	Image* SeparateImages(const(Image)*, const ChannelType, ExceptionInfo*);
 
 	ImageInfo* AcquireImageInfo();
-	ImageInfo* CloneImageInfo(const ImageInfo*);
+	ImageInfo* CloneImageInfo(const(ImageInfo)*);
 	ImageInfo* DestroyImageInfo(ImageInfo*);
 
 	MagickBooleanType ClipImage(Image*);
-	MagickBooleanType ClipImagePath(Image*, const char*, const MagickBooleanType);
-	MagickBooleanType GetImageAlphaChannel(const Image*);
-	MagickBooleanType IsTaintImage(const Image*);
-	MagickBooleanType IsMagickConflict(const char*);
-	MagickBooleanType IsHighDynamicRangeImage(const Image*, ExceptionInfo*);
-	MagickBooleanType IsImageObject(const Image*);
+	MagickBooleanType ClipImagePath(Image*, const(char)*, const MagickBooleanType);
+	MagickBooleanType GetImageAlphaChannel(const(Image)*);
+	MagickBooleanType IsTaintImage(const(Image)*);
+	MagickBooleanType IsMagickConflict(const(char)*);
+	MagickBooleanType IsHighDynamicRangeImage(const(Image)*, ExceptionInfo*);
+	MagickBooleanType IsImageObject(const(Image)*);
 	MagickBooleanType ListMagickInfo(FILE*, ExceptionInfo*);
 	MagickBooleanType ModifyImage(Image**, ExceptionInfo*);
-	MagickBooleanType ResetImagePage(Image*, const char*);
+	MagickBooleanType ResetImagePage(Image*, const(char)*);
 	MagickBooleanType SeparateImageChannel(Image*, const ChannelType);
 	MagickBooleanType SetImageAlphaChannel(Image*, const AlphaChannelType);
 	MagickBooleanType SetImageBackgroundColor(Image*);
-	MagickBooleanType SetImageClipMask(Image*, const Image*);
-	MagickBooleanType SetImageColor(Image*, const MagickPixelPacket*);
+	MagickBooleanType SetImageClipMask(Image*, const(Image)*);
+	MagickBooleanType SetImageColor(Image*, const(MagickPixelPacket)*);
 	MagickBooleanType SetImageExtent(Image*, const size_t, const size_t);
 	MagickBooleanType SetImageInfo(ImageInfo*, const uint, ExceptionInfo*);
-	MagickBooleanType SetImageMask(Image*, const Image*);
+	MagickBooleanType SetImageMask(Image*, const(Image)*);
 	MagickBooleanType SetImageOpacity(Image*, const Quantum);
 	MagickBooleanType SetImageStorageClass(Image*, const ClassType);
 	MagickBooleanType SetImageType(Image*, const ImageType);
 	MagickBooleanType StripImage(Image*);
 	MagickBooleanType SyncImage(Image*);
-	MagickBooleanType SyncImageSettings(const ImageInfo*, Image*);
+	MagickBooleanType SyncImageSettings(const(ImageInfo)*, Image*);
 	MagickBooleanType SyncImagesSettings(ImageInfo*, Image*);
 
-	size_t InterpretImageFilename(const ImageInfo*, Image*, const char*, int, char*);
+	size_t InterpretImageFilename(const(ImageInfo)*, Image*, const(char)*, int, char*);
 
 	ssize_t GetImageReferenceCount(Image*);
 
-	VirtualPixelMethod GetImageVirtualPixelMethod(const Image*);
-	VirtualPixelMethod SetImageVirtualPixelMethod(const Image*, const VirtualPixelMethod);
+	VirtualPixelMethod GetImageVirtualPixelMethod(const(Image)*);
+	VirtualPixelMethod SetImageVirtualPixelMethod(const(Image)*, const VirtualPixelMethod);
 
-	void AcquireNextImage(const ImageInfo*, Image*);
+	void AcquireNextImage(const(ImageInfo)*, Image*);
 	void DestroyImagePixels(Image*);
 	void DisassociateImageStream(Image*);
 	void GetImageException(Image*, ExceptionInfo*);
 	void GetImageInfo(ImageInfo*);
-	void SetImageInfoBlob(ImageInfo*, const void*, const size_t);
+	void SetImageInfoBlob(ImageInfo*, const(void)*, const size_t);
 	void SetImageInfoFile(ImageInfo*, FILE*);
 }
diff --git a/dmagick/c/imageView.d b/dmagick/c/imageView.d
index 327ccac..84be711 100644
--- a/dmagick/c/imageView.d
+++ b/dmagick/c/imageView.d
@@ -12,37 +12,37 @@ extern(C)
 {
 	struct ImageView {}
 
-	alias MagickBooleanType function(const ImageView*, const ImageView*, ImageView*, const ssize_t, const int, void*) DuplexTransferImageViewMethod;
-	alias MagickBooleanType function(const ImageView*, const ssize_t, const int, void*) GetImageViewMethod;
+	alias MagickBooleanType function(const(ImageView)*, const(ImageView)*, ImageView*, const ssize_t, const int, void*) DuplexTransferImageViewMethod;
+	alias MagickBooleanType function(const(ImageView)*, const ssize_t, const int, void*) GetImageViewMethod;
 	alias MagickBooleanType function(ImageView*, const ssize_t, const int, void*) SetImageViewMethod;
-	alias MagickBooleanType function(const ImageView*, ImageView*, const ssize_t, const int, void*) TransferImageViewMethod;
+	alias MagickBooleanType function(const(ImageView)*, ImageView*, const ssize_t, const int, void*) TransferImageViewMethod;
 	alias MagickBooleanType function(ImageView*, const ssize_t, const int, void*) UpdateImageViewMethod;
 
-	char* GetImageViewException(const ImageView*, ExceptionType*);
+	char* GetImageViewException(const(ImageView)*, ExceptionType*);
 
-	const(IndexPacket)* GetImageViewVirtualIndexes(const ImageView*);
+	const(IndexPacket)* GetImageViewVirtualIndexes(const(ImageView)*);
 
-	const(PixelPacket)* GetImageViewVirtualPixels(const ImageView*);
+	const(PixelPacket)* GetImageViewVirtualPixels(const(ImageView)*);
 
-	Image* GetImageViewImage(const ImageView*);
+	Image* GetImageViewImage(const(ImageView)*);
 
-	ImageView* CloneImageView(const ImageView*);
+	ImageView* CloneImageView(const(ImageView)*);
 	ImageView* DestroyImageView(ImageView*);
 	ImageView* NewImageView(Image*);
 	ImageView* NewImageViewRegion(Image*, const ssize_t, const ssize_t, const size_t, const size_t);
 
-	IndexPacket* GetImageViewAuthenticIndexes(const ImageView*);
+	IndexPacket* GetImageViewAuthenticIndexes(const(ImageView)*);
 
 	MagickBooleanType DuplexTransferImageViewIterator(ImageView*, ImageView*, ImageView*, DuplexTransferImageViewMethod, void*);
 	MagickBooleanType GetImageViewIterator(ImageView*, GetImageViewMethod, void*);
-	MagickBooleanType IsImageView(const ImageView*);
+	MagickBooleanType IsImageView(const(ImageView)*);
 	MagickBooleanType SetImageViewIterator(ImageView*, SetImageViewMethod, void*);
 	MagickBooleanType TransferImageViewIterator(ImageView*, ImageView*, TransferImageViewMethod, void*);
 	MagickBooleanType UpdateImageViewIterator(ImageView*, UpdateImageViewMethod, void*);
 
-	PixelPacket* GetImageViewAuthenticPixels(const ImageView*);
+	PixelPacket* GetImageViewAuthenticPixels(const(ImageView)*);
 
-	RectangleInfo GetImageViewExtent(const ImageView*);
+	RectangleInfo GetImageViewExtent(const(ImageView)*);
 
-	void SetImageViewDescription(ImageView*, const char*);
+	void SetImageViewDescription(ImageView*, const(char)*);
 }
diff --git a/dmagick/c/layer.d b/dmagick/c/layer.d
index b71490e..984587b 100644
--- a/dmagick/c/layer.d
+++ b/dmagick/c/layer.d
@@ -38,16 +38,16 @@ extern(C)
 		TrimBoundsLayer
 	}
 
-	Image* CoalesceImages(const Image*, ExceptionInfo*);
-	Image* DisposeImages(const Image*, ExceptionInfo*);
-	Image* CompareImageLayers(const Image*, const ImageLayerMethod, ExceptionInfo*);
-	Image* DeconstructImages(const Image*, ExceptionInfo*);
+	Image* CoalesceImages(const(Image)*, ExceptionInfo*);
+	Image* DisposeImages(const(Image)*, ExceptionInfo*);
+	Image* CompareImageLayers(const(Image)*, const ImageLayerMethod, ExceptionInfo*);
+	Image* DeconstructImages(const(Image)*, ExceptionInfo*);
 	Image* MergeImageLayers(Image*, const ImageLayerMethod, ExceptionInfo*);
-	Image* OptimizeImageLayers(const Image*, ExceptionInfo*);
-	Image* OptimizePlusImageLayers(const Image*, ExceptionInfo*);
+	Image* OptimizeImageLayers(const(Image)*, ExceptionInfo*);
+	Image* OptimizePlusImageLayers(const(Image)*, ExceptionInfo*);
 
 	void CompositeLayers(Image*, const CompositeOperator, Image*, const ssize_t, const ssize_t, ExceptionInfo*);
-	void OptimizeImageTransparency(const Image*, ExceptionInfo*);
+	void OptimizeImageTransparency(const(Image)*, ExceptionInfo*);
 	void RemoveDuplicateLayers(Image**, ExceptionInfo*);
 	void RemoveZeroDelayLayers(Image**, ExceptionInfo*);
 }
diff --git a/dmagick/c/list.d b/dmagick/c/list.d
index 9b91807..0f705e4 100644
--- a/dmagick/c/list.d
+++ b/dmagick/c/list.d
@@ -7,30 +7,30 @@ import dmagick.c.image;
 
 extern(C)
 {
-	Image*  CloneImageList(const Image*, ExceptionInfo*);
-	Image*  CloneImages(const Image*, const char*, ExceptionInfo*);
+	Image*  CloneImageList(const(Image)*, ExceptionInfo*);
+	Image*  CloneImages(const(Image)*, const(char)*, ExceptionInfo*);
 	Image*  DestroyImageList(Image*);
-	Image*  GetFirstImageInList(const Image*);
-	Image*  GetImageFromList(const Image*, const ssize_t);
-	Image*  GetLastImageInList(const Image*);
-	Image*  GetNextImageInList(const Image*);
-	Image*  GetPreviousImageInList(const Image*);
-	Image** ImageListToArray(const Image*, ExceptionInfo*);
+	Image*  GetFirstImageInList(const(Image)*);
+	Image*  GetImageFromList(const(Image)*, const ssize_t);
+	Image*  GetLastImageInList(const(Image)*);
+	Image*  GetNextImageInList(const(Image)*);
+	Image*  GetPreviousImageInList(const(Image)*);
+	Image** ImageListToArray(const(Image)*, ExceptionInfo*);
 	Image*  NewImageList();
 	Image*  RemoveImageFromList(Image**);
 	Image*  RemoveLastImageFromList(Image**);
 	Image*  RemoveFirstImageFromList(Image**);
-	Image*  SpliceImageIntoList(Image**, const size_t, const Image*);
+	Image*  SpliceImageIntoList(Image**, const size_t, const(Image)*);
 	Image*  SplitImageList(Image*);
-	Image*  SyncNextImageInList(const Image*);
+	Image*  SyncNextImageInList(const(Image)*);
 
-	size_t GetImageListLength(const Image*);
+	size_t GetImageListLength(const(Image)*);
 
-	ssize_t GetImageIndexInList(const Image*);
+	ssize_t GetImageIndexInList(const(Image)*);
 
-	void AppendImageToList(Image**, const Image*);
+	void AppendImageToList(Image**, const(Image)*);
 	void DeleteImageFromList(Image**);
-	void DeleteImages(Image**, const char*, ExceptionInfo*);
+	void DeleteImages(Image**, const(char)*, ExceptionInfo*);
 	void InsertImageInList(Image**, Image*);
 	void PrependImageToList(Image**, Image*);
 	void ReplaceImageInList(Image**, Image*);
diff --git a/dmagick/c/locale.d b/dmagick/c/locale.d
index 2cb2296..6fe476f 100644
--- a/dmagick/c/locale.d
+++ b/dmagick/c/locale.d
@@ -26,15 +26,15 @@ extern(C)
 			signature;
 	}
 
-	char** GetLocaleList(const char*, size_t*, ExceptionInfo*);
+	char** GetLocaleList(const(char)*, size_t*, ExceptionInfo*);
 
-	const(char)* GetLocaleMessage(const char*);
+	const(char)* GetLocaleMessage(const(char)*);
 
-	const(LocaleInfo)*  GetLocaleInfo_(const char*, ExceptionInfo*);
-	const(LocaleInfo)** GetLocaleInfoList(const char*, size_t*, ExceptionInfo*);
+	const(LocaleInfo)*  GetLocaleInfo_(const(char)*, ExceptionInfo*);
+	const(LocaleInfo)** GetLocaleInfoList(const(char)*, size_t*, ExceptionInfo*);
 
 	LinkedListInfo* DestroyLocaleOptions(LinkedListInfo*);
-	LinkedListInfo* GetLocaleOptions(const char*, ExceptionInfo*);
+	LinkedListInfo* GetLocaleOptions(const(char)*, ExceptionInfo*);
 
 	MagickBooleanType ListLocaleInfo(FILE*, ExceptionInfo*);
 	MagickBooleanType LocaleComponentGenesis();
diff --git a/dmagick/c/log.d b/dmagick/c/log.d
index abdc0f3..6211dd7 100644
--- a/dmagick/c/log.d
+++ b/dmagick/c/log.d
@@ -35,22 +35,22 @@ extern(C)
 
 	struct LogInfo {}
 
-	char** GetLogList(const char*, size_t*, ExceptionInfo*);
+	char** GetLogList(const(char)*, size_t*, ExceptionInfo*);
 
 	const(char)* GetLogName();
-	const(char)* SetLogName(const char*);
+	const(char)* SetLogName(const(char)*);
 
-	const(LogInfo)** GetLogInfoList(const char*, size_t*, ExceptionInfo*);
+	const(LogInfo)** GetLogInfoList(const(char)*, size_t*, ExceptionInfo*);
 
-	LogEventType SetLogEventMask(const char*);
+	LogEventType SetLogEventMask(const(char)*);
 
 	MagickBooleanType IsEventLogging();
 	MagickBooleanType ListLogInfo(FILE*, ExceptionInfo*);
 	MagickBooleanType LogComponentGenesis();
-	MagickBooleanType LogMagickEvent(const LogEventType, const char*, const char*, const size_t, const char*, ...);
-	MagickBooleanType LogMagickEventList(const LogEventType, const char*, const char*, const size_t, const char*, va_list);
+	MagickBooleanType LogMagickEvent(const LogEventType, const(char)*, const(char)*, const size_t, const(char)*, ...);
+	MagickBooleanType LogMagickEventList(const LogEventType, const(char)*, const(char)*, const size_t, const(char)*, va_list);
 
 	void CloseMagickLog();
 	void LogComponentTerminus();
-	void SetLogFormat(const char*);
+	void SetLogFormat(const(char)*);
 }
diff --git a/dmagick/c/magic.d b/dmagick/c/magic.d
index 864a0bc..2a35e0d 100644
--- a/dmagick/c/magic.d
+++ b/dmagick/c/magic.d
@@ -36,15 +36,15 @@ extern(C)
 			signature;
 	}
 
-	char** GetMagicList(const char*, size_t*, ExceptionInfo*);
+	char** GetMagicList(const(char)*, size_t*, ExceptionInfo*);
 
-	const(char)* GetMagicName(const MagicInfo*);
+	const(char)* GetMagicName(const(MagicInfo)*);
 
 	MagickBooleanType ListMagicInfo(FILE*, ExceptionInfo*);
 	MagickBooleanType MagicComponentGenesis();
 
-	const(MagicInfo)*  GetMagicInfo(const ubyte*, const size_t, ExceptionInfo*);
-	const(MagicInfo)** GetMagicInfoList(const char*, size_t*, ExceptionInfo*);
+	const(MagicInfo)*  GetMagicInfo(const(ubyte)*, const size_t, ExceptionInfo*);
+	const(MagicInfo)** GetMagicInfoList(const(char)*, size_t*, ExceptionInfo*);
 
 	void MagicComponentTerminus();
 }
diff --git a/dmagick/c/magick.d b/dmagick/c/magick.d
index 7a46675..742c3de 100644
--- a/dmagick/c/magick.d
+++ b/dmagick/c/magick.d
@@ -20,9 +20,9 @@ extern(C)
 		EncoderThreadSupport = 0x0002
 	}
 
-	alias Image* function(const ImageInfo*, ExceptionInfo*) DecodeImageHandler;
-	alias MagickBooleanType function(const ImageInfo*, Image*) EncodeImageHandler;
-	alias MagickBooleanType function(const ubyte*, const size_t) IsImageFormatHandler;
+	alias Image* function(const(ImageInfo)*, ExceptionInfo*) DecodeImageHandler;
+	alias MagickBooleanType function(const(ImageInfo)*, Image*) EncodeImageHandler;
+	alias MagickBooleanType function(const(ubyte)*, const size_t) IsImageFormatHandler;
 
 	struct MagickInfo
 	{
@@ -72,36 +72,36 @@ extern(C)
 			signature;
 	}
 
-	char** GetMagickList(const char*, size_t*, ExceptionInfo*);
+	char** GetMagickList(const(char)*, size_t*, ExceptionInfo*);
 
-	const(char)* GetMagickDescription(const MagickInfo*);
+	const(char)* GetMagickDescription(const(MagickInfo)*);
 
-	DecodeImageHandler* GetImageDecoder(const MagickInfo*);
+	DecodeImageHandler* GetImageDecoder(const(MagickInfo)*);
 
-	EncodeImageHandler* GetImageEncoder(const MagickInfo*);
+	EncodeImageHandler* GetImageEncoder(const(MagickInfo)*);
 
 	int GetMagickPrecision();
 	int SetMagickPrecision(const int);
 
-	MagickBooleanType GetImageMagick(const ubyte*, const size_t, char*);
-	MagickBooleanType GetMagickAdjoin(const MagickInfo*);
-	MagickBooleanType GetMagickBlobSupport(const MagickInfo*);
-	MagickBooleanType GetMagickEndianSupport(const MagickInfo*);
-	MagickBooleanType GetMagickRawSupport(const MagickInfo*);
-	MagickBooleanType GetMagickSeekableStream(const MagickInfo*);
+	MagickBooleanType GetImageMagick(const(ubyte)*, const size_t, char*);
+	MagickBooleanType GetMagickAdjoin(const(MagickInfo)*);
+	MagickBooleanType GetMagickBlobSupport(const(MagickInfo)*);
+	MagickBooleanType GetMagickEndianSupport(const(MagickInfo)*);
+	MagickBooleanType GetMagickRawSupport(const(MagickInfo)*);
+	MagickBooleanType GetMagickSeekableStream(const(MagickInfo)*);
 	MagickBooleanType IsMagickInstantiated();
 	MagickBooleanType MagickComponentGenesis();
-	MagickBooleanType UnregisterMagickInfo(const char*);
+	MagickBooleanType UnregisterMagickInfo(const(char)*);
 
-	const(MagickInfo)*  GetMagickInfo(const char*, ExceptionInfo*);
-	const(MagickInfo)** GetMagickInfoList(const char*, size_t*, ExceptionInfo*);
+	const(MagickInfo)*  GetMagickInfo(const(char)*, ExceptionInfo*);
+	const(MagickInfo)** GetMagickInfoList(const(char)*, size_t*, ExceptionInfo*);
 
 	MagickInfo* RegisterMagickInfo(MagickInfo*);
-	MagickInfo* SetMagickInfo(const char*);
+	MagickInfo* SetMagickInfo(const(char)*);
 
-	MagickStatusType GetMagickThreadSupport(const MagickInfo*);
+	MagickStatusType GetMagickThreadSupport(const(MagickInfo)*);
 
 	void MagickComponentTerminus();
-	void MagickCoreGenesis(const char*, const MagickBooleanType);
+	void MagickCoreGenesis(const(char)*, const MagickBooleanType);
 	void MagickCoreTerminus();
 }
diff --git a/dmagick/c/magickDelegate.d b/dmagick/c/magickDelegate.d
index 12c1d55..8b1f544 100644
--- a/dmagick/c/magickDelegate.d
+++ b/dmagick/c/magickDelegate.d
@@ -33,19 +33,19 @@ extern(C)
 			signature;
 	}
 
-	char*  GetDelegateCommand(const ImageInfo*, Image*, const char*, const char*, ExceptionInfo*);
-	char** GetDelegateList(const char *,size_t *,ExceptionInfo *);
+	char*  GetDelegateCommand(const(ImageInfo)*, Image*, const(char)*, const(char)*, ExceptionInfo*);
+	char** GetDelegateList(const(char)*,size_t *,ExceptionInfo *);
 
-	const(char)* GetDelegateCommands(const DelegateInfo*);
+	const(char)* GetDelegateCommands(const(DelegateInfo)*);
 
-	const(DelegateInfo)*  GetDelegateInfo(const char*, const char*, ExceptionInfo* exception);
-	const(DelegateInfo)** GetDelegateInfoList(const char*, size_t*, ExceptionInfo*);
+	const(DelegateInfo)*  GetDelegateInfo(const(char)*, const(char)*, ExceptionInfo* exception);
+	const(DelegateInfo)** GetDelegateInfoList(const(char)*, size_t*, ExceptionInfo*);
 
-	ssize_t GetDelegateMode(const DelegateInfo*);
+	ssize_t GetDelegateMode(const(DelegateInfo)*);
 
 	MagickBooleanType DelegateComponentGenesis();
-	MagickBooleanType GetDelegateThreadSupport(const DelegateInfo*);
-	MagickBooleanType InvokeDelegate(ImageInfo*, Image*, const char*, const char*, ExceptionInfo*);
+	MagickBooleanType GetDelegateThreadSupport(const(DelegateInfo)*);
+	MagickBooleanType InvokeDelegate(ImageInfo*, Image*, const(char)*, const(char)*, ExceptionInfo*);
 	MagickBooleanType ListDelegateInfo(FILE*, ExceptionInfo*);
 
 	void DelegateComponentTerminus();
diff --git a/dmagick/c/magickModule.d b/dmagick/c/magickModule.d
index b6efd41..364d511 100644
--- a/dmagick/c/magickModule.d
+++ b/dmagick/c/magickModule.d
@@ -44,20 +44,20 @@ extern(C)
 			signature;
 	}
 
-	size_t ImageFilterHandler(Image**, const int, const char**, ExceptionInfo*);
+	size_t ImageFilterHandler(Image**, const int, const(char)**, ExceptionInfo*);
 
-	char** GetModuleList(const char*, const MagickModuleType, size_t*, ExceptionInfo*);
+	char** GetModuleList(const(char)*, const MagickModuleType, size_t*, ExceptionInfo*);
 
-	const(ModuleInfo)** GetModuleInfoList(const char*, size_t*, ExceptionInfo*);
+	const(ModuleInfo)** GetModuleInfoList(const(char)*, size_t*, ExceptionInfo*);
 
 	MagickBooleanType InitializeModuleList(ExceptionInfo*);
-	MagickBooleanType InvokeDynamicImageFilter(const char*, Image**, const int, const char**, ExceptionInfo*);
+	MagickBooleanType InvokeDynamicImageFilter(const(char)*, Image**, const int, const(char)**, ExceptionInfo*);
 	MagickBooleanType ListModuleInfo(FILE*, ExceptionInfo*);
 	MagickBooleanType ModuleComponentGenesis();
-	MagickBooleanType OpenModule(const char*, ExceptionInfo*);
+	MagickBooleanType OpenModule(const(char)*, ExceptionInfo*);
 	MagickBooleanType OpenModules(ExceptionInfo*);
 
-	ModuleInfo* GetModuleInfo(const char*, ExceptionInfo*);
+	ModuleInfo* GetModuleInfo(const(char)*, ExceptionInfo*);
 
 	void DestroyModuleList();
 	void ModuleComponentTerminus();
diff --git a/dmagick/c/magickString.d b/dmagick/c/magickString.d
index 838ae5d..8ebac5a 100644
--- a/dmagick/c/magickString.d
+++ b/dmagick/c/magickString.d
@@ -23,56 +23,56 @@ extern(C)
 			signature;
 	}
 
-	char*  AcquireString(const char*);
-	char*  CloneString(char**, const char*);
-	char*  ConstantString(const char*);
+	char*  AcquireString(const(char)*);
+	char*  CloneString(char**, const(char)*);
+	char*  ConstantString(const(char)*);
 	char*  DestroyString(char*);
 	char** DestroyStringList(char**);
-	char*  EscapeString(const char*, const char);
-	char*  FileToString(const char*, const size_t, ExceptionInfo*);
-	char*  GetEnvironmentValue(const char*);
-	char*  StringInfoToHexString(const StringInfo*);
-	char*  StringInfoToString(const StringInfo*);
-	char** StringToArgv(const char*, int*);
-	char*  StringToken(const char*, char**);
-	char** StringToList(const char*);
+	char*  EscapeString(const(char)*, const char);
+	char*  FileToString(const(char)*, const size_t, ExceptionInfo*);
+	char*  GetEnvironmentValue(const(char)*);
+	char*  StringInfoToHexString(const(StringInfo)*);
+	char*  StringInfoToString(const(StringInfo)*);
+	char** StringToArgv(const(char)*, int*);
+	char*  StringToken(const(char)*, char**);
+	char** StringToList(const(char)*);
 
-	const(char)* GetStringInfoPath(const StringInfo*);
+	const(char)* GetStringInfoPath(const(StringInfo)*);
 
-	int	CompareStringInfo(const StringInfo*, const StringInfo*);
-	int	LocaleCompare(const char*, const char*);
-	int	LocaleNCompare(const char*, const char*, const size_t);
+	int	CompareStringInfo(const(StringInfo)*, const(StringInfo)*);
+	int	LocaleCompare(const(char)*, const(char)*);
+	int	LocaleNCompare(const(char)*, const(char)*, const size_t);
 
-	MagickBooleanType ConcatenateString(char**, const char*);
-	MagickBooleanType SubstituteString(char**, const char*, const char*);
+	MagickBooleanType ConcatenateString(char**, const(char)*);
+	MagickBooleanType SubstituteString(char**, const(char)*, const(char)*);
 
-	size_t ConcatenateMagickString(char*, const char*, const size_t);
-	size_t CopyMagickString(char*, const char*, const size_t);
-	size_t GetStringInfoLength(const StringInfo*);
+	size_t ConcatenateMagickString(char*, const(char)*, const size_t);
+	size_t CopyMagickString(char*, const(char)*, const size_t);
+	size_t GetStringInfoLength(const(StringInfo)*);
 
 	ssize_t	FormatMagickSize(const MagickSizeType, const MagickBooleanType, char*);
-	ssize_t	FormatMagickString(char*, const size_t, const char*, ...);
-	ssize_t	FormatMagickStringList(char*, const size_t, const char*, va_list);
+	ssize_t	FormatMagickString(char*, const size_t, const(char)*, ...);
+	ssize_t	FormatMagickStringList(char*, const size_t, const(char)*, va_list);
 	ssize_t	FormatMagickTime(const time_t, const size_t, char*);
 
 	StringInfo* AcquireStringInfo(const size_t);
-	StringInfo* CloneStringInfo(const StringInfo*);
-	StringInfo* ConfigureFileToStringInfo(const char*);
+	StringInfo* CloneStringInfo(const(StringInfo)*);
+	StringInfo* ConfigureFileToStringInfo(const(char)*);
 	StringInfo* DestroyStringInfo(StringInfo*);
-	StringInfo* FileToStringInfo(const char*, const size_t, ExceptionInfo*);
+	StringInfo* FileToStringInfo(const(char)*, const size_t, ExceptionInfo*);
 	StringInfo* SplitStringInfo(StringInfo*, const size_t);
-	StringInfo* StringToStringInfo(const char*);
+	StringInfo* StringToStringInfo(const(char)*);
 
-	ubyte* GetStringInfoDatum(const StringInfo*);
+	ubyte* GetStringInfoDatum(const(StringInfo)*);
 
-	void ConcatenateStringInfo(StringInfo*, const StringInfo*);
+	void ConcatenateStringInfo(StringInfo*, const(StringInfo)*);
 	void LocaleLower(char*);
 	void LocaleUpper(char*);
-	void PrintStringInfo(FILE *file, const char*, const StringInfo*);
+	void PrintStringInfo(FILE *file, const(char)*, const(StringInfo)*);
 	void ResetStringInfo(StringInfo*);
-	void SetStringInfo(StringInfo*, const StringInfo*);
-	void SetStringInfoDatum(StringInfo*, const ubyte*);
+	void SetStringInfo(StringInfo*, const(StringInfo)*);
+	void SetStringInfoDatum(StringInfo*, const(ubyte)*);
 	void SetStringInfoLength(StringInfo*, const size_t);
-	void SetStringInfoPath(StringInfo*, const char*);
+	void SetStringInfoPath(StringInfo*, const(char)*);
 	void StripString(char*);
 }
diff --git a/dmagick/c/matrix.d b/dmagick/c/matrix.d
index ecbd998..db4c5e2 100644
--- a/dmagick/c/matrix.d
+++ b/dmagick/c/matrix.d
@@ -9,5 +9,5 @@ extern(C)
 
 	MagickBooleanType GaussJordanElimination(double**, double**, const size_t, const size_t);
 
-	void LeastSquaresAddTerms(double**, double**, const double*, const double*, const size_t, const size_t);
+	void LeastSquaresAddTerms(double**, double**, const(double)*, const(double)*, const size_t, const size_t);
 }
diff --git a/dmagick/c/memory.d b/dmagick/c/memory.d
index 8c10eeb..ab6686f 100644
--- a/dmagick/c/memory.d
+++ b/dmagick/c/memory.d
@@ -9,7 +9,7 @@ extern(C)
 	void* AcquireAlignedMemory(const size_t, const size_t);
 	void* AcquireMagickMemory(const size_t);
 	void* AcquireQuantumMemory(const size_t, const size_t);
-	void* CopyMagickMemory(void*, const void*, const size_t);
+	void* CopyMagickMemory(void*, const(void)*, const size_t);
 	void  DestroyMagickMemory();
 	void  GetMagickMemoryMethods(AcquireMemoryHandler*, ResizeMemoryHandler*, DestroyMemoryHandler*);
 	void* RelinquishAlignedMemory(void*);
diff --git a/dmagick/c/mime.d b/dmagick/c/mime.d
index c28af96..9fb66fb 100644
--- a/dmagick/c/mime.d
+++ b/dmagick/c/mime.d
@@ -9,18 +9,18 @@ extern(C)
 {
 	struct MimeInfo {}
 
-	char** GetMimeList(const char*, size_t*, ExceptionInfo*);
-	char*  MagickToMime(const char*);
+	char** GetMimeList(const(char)*, size_t*, ExceptionInfo*);
+	char*  MagickToMime(const(char)*);
 
-	const(char)* GetMimeDescription(const MimeInfo*);
-	const(char)* GetMimeType(const MimeInfo*);
+	const(char)* GetMimeDescription(const(MimeInfo)*);
+	const(char)* GetMimeType(const(MimeInfo)*);
 
 	MagickBooleanType ListMimeInfo(FILE*, ExceptionInfo*);
-	MagickBooleanType LoadMimeLists(const char*, ExceptionInfo*);
+	MagickBooleanType LoadMimeLists(const(char)*, ExceptionInfo*);
 	MagickBooleanType MimeComponentGenesis();
 
-	const(MimeInfo)*  GetMimeInfo(const char*, const ubyte*, const size_t, ExceptionInfo*);
-	const(MimeInfo)** GetMimeInfoList(const char*, size_t*, ExceptionInfo*);
+	const(MimeInfo)*  GetMimeInfo(const(char)*, const(ubyte)*, const size_t, ExceptionInfo*);
+	const(MimeInfo)** GetMimeInfoList(const(char)*, size_t*, ExceptionInfo*);
 
 	void MimeComponentTerminus();
 }
diff --git a/dmagick/c/monitor.d b/dmagick/c/monitor.d
index 6d0651e..a821c78 100644
--- a/dmagick/c/monitor.d
+++ b/dmagick/c/monitor.d
@@ -5,7 +5,7 @@ import dmagick.c.magickType;
 
 extern(C)
 {
-	alias MagickBooleanType function(const char*, const MagickOffsetType, const MagickSizeType, void*) MagickProgressMonitor;
+	alias MagickBooleanType function(const(char)*, const MagickOffsetType, const MagickSizeType, void*) MagickProgressMonitor;
 
 	MagickProgressMonitor SetImageProgressMonitor(Image*, const MagickProgressMonitor, void*);
 	MagickProgressMonitor SetImageInfoProgressMonitor(ImageInfo*, const MagickProgressMonitor, void*);
diff --git a/dmagick/c/montage.d b/dmagick/c/montage.d
index 0603e79..509f04d 100644
--- a/dmagick/c/montage.d
+++ b/dmagick/c/montage.d
@@ -55,11 +55,11 @@ extern(C)
 			signature;
 	}
 
-	Image* MontageImages(const Image*, const MontageInfo*, ExceptionInfo*);
-	Image* MontageImageList(const ImageInfo*, const MontageInfo*, const Image*, ExceptionInfo*);
+	Image* MontageImages(const(Image)*, const(MontageInfo)*, ExceptionInfo*);
+	Image* MontageImageList(const(ImageInfo)*, const(MontageInfo)*, const(Image)*, ExceptionInfo*);
 
-	MontageInfo* CloneMontageInfo(const ImageInfo*, const MontageInfo*);
+	MontageInfo* CloneMontageInfo(const(ImageInfo)*, const(MontageInfo)*);
 	MontageInfo* DestroyMontageInfo(MontageInfo*);
 
-	void GetMontageInfo(const ImageInfo*, MontageInfo*);
+	void GetMontageInfo(const(ImageInfo)*, MontageInfo*);
 }
diff --git a/dmagick/c/morphology.d b/dmagick/c/morphology.d
index baae868..2478387 100644
--- a/dmagick/c/morphology.d
+++ b/dmagick/c/morphology.d
@@ -107,14 +107,14 @@ extern(C)
 	}
 
 
-	KernelInfo* AcquireKernelInfo(const char*);
-	KernelInfo* AcquireKernelBuiltIn(const KernelInfoType, const GeometryInfo*);
-	KernelInfo* CloneKernelInfo(const KernelInfo*);
+	KernelInfo* AcquireKernelInfo(const(char)*);
+	KernelInfo* AcquireKernelBuiltIn(const KernelInfoType, const(GeometryInfo)*);
+	KernelInfo* CloneKernelInfo(const(KernelInfo)*);
 	KernelInfo* DestroyKernelInfo(KernelInfo*);
 
-	Image* MorphologyImage(const Image*, const MorphologyMethod, const ssize_t, const KernelInfo*, ExceptionInfo*);
-	Image* MorphologyImageChannel(const Image*, const ChannelType, const MorphologyMethod, const ssize_t, const KernelInfo*, ExceptionInfo*);
+	Image* MorphologyImage(const(Image)*, const MorphologyMethod, const ssize_t, const(KernelInfo)*, ExceptionInfo*);
+	Image* MorphologyImageChannel(const(Image)*, const ChannelType, const MorphologyMethod, const ssize_t, const(KernelInfo)*, ExceptionInfo*);
 
-	void ScaleGeometryKernelInfo(KernelInfo*, const char*);
+	void ScaleGeometryKernelInfo(KernelInfo*, const(char)*);
 	void ShowKernelInfo(KernelInfo*);
 }
diff --git a/dmagick/c/option.d b/dmagick/c/option.d
index 88db7e4..159a5c4 100644
--- a/dmagick/c/option.d
+++ b/dmagick/c/option.d
@@ -110,23 +110,23 @@ extern(C)
 	}
 
 	char** GetMagickOptions(const MagickOption);
-	char*  GetNextImageOption(const ImageInfo*);
-	char*  RemoveImageOption(ImageInfo*, const char*);
+	char*  GetNextImageOption(const(ImageInfo)*);
+	char*  RemoveImageOption(ImageInfo*, const(char)*);
 
-	const(char)* GetImageOption(const ImageInfo*, const char*);
+	const(char)* GetImageOption(const(ImageInfo)*, const(char)*);
 	const(char)* MagickOptionToMnemonic(const MagickOption, const ssize_t);
 
-	MagickBooleanType CloneImageOptions(ImageInfo*, const ImageInfo*);
-	MagickBooleanType DefineImageOption(ImageInfo*, const char*);
-	MagickBooleanType DeleteImageOption(ImageInfo*, const char*);
-	MagickBooleanType IsMagickOption(const char*);
+	MagickBooleanType CloneImageOptions(ImageInfo*, const(ImageInfo)*);
+	MagickBooleanType DefineImageOption(ImageInfo*, const(char)*);
+	MagickBooleanType DeleteImageOption(ImageInfo*, const(char)*);
+	MagickBooleanType IsMagickOption(const(char)*);
 	MagickBooleanType ListMagickOptions(FILE*, const MagickOption, ExceptionInfo*);
-	MagickBooleanType SetImageOption(ImageInfo*, const char*, const char*);
+	MagickBooleanType SetImageOption(ImageInfo*, const(char)*, const(char)*);
 
-	ssize_t ParseChannelOption(const char*);
-	ssize_t ParseMagickOption(const MagickOption, const MagickBooleanType,const char*);
+	ssize_t ParseChannelOption(const(char)*);
+	ssize_t ParseMagickOption(const MagickOption, const MagickBooleanType,const(char)*);
 
 	void DestroyImageOptions(ImageInfo*);
-	void ResetImageOptions(const ImageInfo*);
-	void ResetImageOptionIterator(const ImageInfo*);
+	void ResetImageOptions(const(ImageInfo)*);
+	void ResetImageOptionIterator(const(ImageInfo)*);
 }
diff --git a/dmagick/c/paint.d b/dmagick/c/paint.d
index 2b366f5..a0e287b 100644
--- a/dmagick/c/paint.d
+++ b/dmagick/c/paint.d
@@ -10,12 +10,12 @@ import dmagick.c.pixel;
 
 extern(C)
 {
-	Image* OilPaintImage(const Image*, const double, ExceptionInfo*);
+	Image* OilPaintImage(const(Image)*, const double, ExceptionInfo*);
 
-	MagickBooleanType FloodfillPaintImage(Image*, const ChannelType, const DrawInfo*, const MagickPixelPacket*, const ssize_t, const ssize_t, const MagickBooleanType);
-	MagickBooleanType GradientImage(Image*, const GradientType, const SpreadMethod, const PixelPacket*, const PixelPacket*);
-	MagickBooleanType OpaquePaintImage(Image*, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType);
-	MagickBooleanType OpaquePaintImageChannel(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType);
-	MagickBooleanType TransparentPaintImage(Image*, const MagickPixelPacket*, const Quantum, const MagickBooleanType);
-	MagickBooleanType TransparentPaintImageChroma(Image*, const MagickPixelPacket*, const MagickPixelPacket*, const Quantum, const MagickBooleanType);
+	MagickBooleanType FloodfillPaintImage(Image*, const ChannelType, const(DrawInfo)*, const(MagickPixelPacket)*, const ssize_t, const ssize_t, const MagickBooleanType);
+	MagickBooleanType GradientImage(Image*, const GradientType, const SpreadMethod, const(PixelPacket)*, const(PixelPacket)*);
+	MagickBooleanType OpaquePaintImage(Image*, const(MagickPixelPacket)*, const(MagickPixelPacket)*, const MagickBooleanType);
+	MagickBooleanType OpaquePaintImageChannel(Image*, const ChannelType, const(MagickPixelPacket)*, const(MagickPixelPacket)*, const MagickBooleanType);
+	MagickBooleanType TransparentPaintImage(Image*, const(MagickPixelPacket)*, const Quantum, const MagickBooleanType);
+	MagickBooleanType TransparentPaintImageChroma(Image*, const(MagickPixelPacket)*, const(MagickPixelPacket)*, const Quantum, const MagickBooleanType);
 }
diff --git a/dmagick/c/pixel.d b/dmagick/c/pixel.d
index 95f4cfb..ee8dc8f 100644
--- a/dmagick/c/pixel.d
+++ b/dmagick/c/pixel.d
@@ -67,8 +67,8 @@ extern(C)
 
 	}
 
-	MagickBooleanType ExportImagePixels(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, const char*, const StorageType, void*, ExceptionInfo*);
-	MagickBooleanType ImportImagePixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t, const char*, const StorageType, const void*);
+	MagickBooleanType ExportImagePixels(const(Image)*, const ssize_t, const ssize_t, const size_t, const size_t, const(char)*, const StorageType, void*, ExceptionInfo*);
+	MagickBooleanType ImportImagePixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t, const(char)*, const StorageType, const(void)*);
 
-	void GetMagickPixelPacket(const Image*, MagickPixelPacket*);
+	void GetMagickPixelPacket(const(Image)*, MagickPixelPacket*);
 }
diff --git a/dmagick/c/policy.d b/dmagick/c/policy.d
index e5f742b..27e4e36 100644
--- a/dmagick/c/policy.d
+++ b/dmagick/c/policy.d
@@ -29,12 +29,12 @@ extern(C)
 
 	struct PolicyInfo {}
 
-	char*  GetPolicyValue(const char* name);
-	char** GetPolicyList(const char*, size_t*, ExceptionInfo*);
+	char*  GetPolicyValue(const(char)* name);
+	char** GetPolicyList(const(char)*, size_t*, ExceptionInfo*);
 
-	const(PolicyInfo)** GetPolicyInfoList(const char*, size_t*, ExceptionInfo*);
+	const(PolicyInfo)** GetPolicyInfoList(const(char)*, size_t*, ExceptionInfo*);
 
-	MagickBooleanType IsRightsAuthorized(const PolicyDomain, const PolicyRights, const char*);
+	MagickBooleanType IsRightsAuthorized(const PolicyDomain, const PolicyRights, const(char)*);
 	MagickBooleanType ListPolicyInfo(FILE*, ExceptionInfo*);
 	MagickBooleanType PolicyComponentGenesis();
 
diff --git a/dmagick/c/profile.d b/dmagick/c/profile.d
index b984b4f..e499a31 100644
--- a/dmagick/c/profile.d
+++ b/dmagick/c/profile.d
@@ -30,18 +30,18 @@ extern(C)
 		RelativeIntent
 	}
 
-	char* GetNextImageProfile(const Image*);
+	char* GetNextImageProfile(const(Image)*);
 
-	const(StringInfo)* GetImageProfile(const Image *,const char *);
+	const(StringInfo)* GetImageProfile(const(Image)*, const(char)*);
 
-	MagickBooleanType CloneImageProfiles(Image*, const Image*);
-	MagickBooleanType DeleteImageProfile(Image*, const char*);
-	MagickBooleanType ProfileImage(Image*, const char*, const void*, const size_t, const MagickBooleanType);
-	MagickBooleanType SetImageProfile(Image*, const char*, const StringInfo*);
+	MagickBooleanType CloneImageProfiles(Image*, const(Image)*);
+	MagickBooleanType DeleteImageProfile(Image*, const(char)*);
+	MagickBooleanType ProfileImage(Image*, const(char)*, const(void)*, const size_t, const MagickBooleanType);
+	MagickBooleanType SetImageProfile(Image*, const(char)*, const(StringInfo)*);
 	MagickBooleanType SyncImageProfiles(Image*);
 
-	StringInfo* RemoveImageProfile(Image*, const char*);
+	StringInfo* RemoveImageProfile(Image*, const(char)*);
 
 	void DestroyImageProfiles(Image*);
-	void ResetImageProfileIterator(const Image*);
+	void ResetImageProfileIterator(const(Image)*);
 }
diff --git a/dmagick/c/property.d b/dmagick/c/property.d
index 7e543fb..e3fdfb0 100644
--- a/dmagick/c/property.d
+++ b/dmagick/c/property.d
@@ -7,20 +7,20 @@ import dmagick.c.magickType;
 
 extern(C)
 {
-	char* GetNextImageProperty(const Image*);
-	char* InterpretImageProperties(const ImageInfo*, Image*, const char*);
-	char* RemoveImageProperty(Image*, const char*);
+	char* GetNextImageProperty(const(Image)*);
+	char* InterpretImageProperties(const(ImageInfo)*, Image*, const(char)*);
+	char* RemoveImageProperty(Image*, const(char)*);
 
-	const(char)* GetImageProperty(const Image*, const char*);
-	const(char)* GetMagickProperty(const ImageInfo*, Image*, const char*);
+	const(char)* GetImageProperty(const(Image)*, const(char)*);
+	const(char)* GetMagickProperty(const(ImageInfo)*, Image*, const(char)*);
 
-	MagickBooleanType CloneImageProperties(Image*, const Image*);
-	MagickBooleanType DefineImageProperty(Image*, const char*);
-	MagickBooleanType DeleteImageProperty(Image*, const char*);
-	MagickBooleanType FormatImageProperty(Image*, const char*, const char*, ...);
-	MagickBooleanType FormatImagePropertyList(Image*, const char*, const char*, va_list);
-	MagickBooleanType SetImageProperty(Image*, const char*, const char*);
+	MagickBooleanType CloneImageProperties(Image*, const(Image)*);
+	MagickBooleanType DefineImageProperty(Image*, const(char)*);
+	MagickBooleanType DeleteImageProperty(Image*, const(char)*);
+	MagickBooleanType FormatImageProperty(Image*, const(char)*, const(char)*, ...);
+	MagickBooleanType FormatImagePropertyList(Image*, const(char)*, const(char)*, va_list);
+	MagickBooleanType SetImageProperty(Image*, const(char)*, const(char)*);
 
 	void DestroyImageProperties(Image*);
-	void ResetImagePropertyIterator(const Image*);
+	void ResetImagePropertyIterator(const(Image)*);
 }
diff --git a/dmagick/c/quantize.d b/dmagick/c/quantize.d
index 72584e2..c090cd5 100644
--- a/dmagick/c/quantize.d
+++ b/dmagick/c/quantize.d
@@ -41,13 +41,13 @@ extern(C)
 	MagickBooleanType CompressImageColormap(Image*);
 	MagickBooleanType GetImageQuantizeError(Image*);
 	MagickBooleanType PosterizeImage(Image*, const size_t, const MagickBooleanType);
-	MagickBooleanType QuantizeImage(const QuantizeInfo*, Image*);
-	MagickBooleanType QuantizeImages(const QuantizeInfo*, Image*);
-	MagickBooleanType RemapImage(const QuantizeInfo*, Image*, const Image*);
-	MagickBooleanType RemapImages(const QuantizeInfo*, Image*, const Image*);
+	MagickBooleanType QuantizeImage(const(QuantizeInfo)*, Image*);
+	MagickBooleanType QuantizeImages(const(QuantizeInfo)*, Image*);
+	MagickBooleanType RemapImage(const(QuantizeInfo)*, Image*, const(Image)*);
+	MagickBooleanType RemapImages(const(QuantizeInfo)*, Image*, const(Image)*);
 
-	QuantizeInfo* AcquireQuantizeInfo(const ImageInfo*);
-	QuantizeInfo* CloneQuantizeInfo(const QuantizeInfo*);
+	QuantizeInfo* AcquireQuantizeInfo(const(ImageInfo)*);
+	QuantizeInfo* CloneQuantizeInfo(const(QuantizeInfo)*);
 	QuantizeInfo* DestroyQuantizeInfo(QuantizeInfo*);
 
 	void GetQuantizeInfo(QuantizeInfo*);
diff --git a/dmagick/c/quantum.d b/dmagick/c/quantum.d
index 5d534dd..bd774af 100644
--- a/dmagick/c/quantum.d
+++ b/dmagick/c/quantum.d
@@ -78,22 +78,22 @@ extern(C)
 		return(cast(ubyte) (((quantum+128UL)-((quantum+128UL) >> 8)) >> 8));
 	}
 
-	MagickBooleanType SetQuantumDepth(const Image*, QuantumInfo*, const size_t);
-	MagickBooleanType SetQuantumFormat(const Image*, QuantumInfo*, const QuantumFormatType);
-	MagickBooleanType SetQuantumPad(const Image*, QuantumInfo*, const size_t);
+	MagickBooleanType SetQuantumDepth(const(Image)*, QuantumInfo*, const size_t);
+	MagickBooleanType SetQuantumFormat(const(Image)*, QuantumInfo*, const QuantumFormatType);
+	MagickBooleanType SetQuantumPad(const(Image)*, QuantumInfo*, const size_t);
 
-	QuantumInfo* AcquireQuantumInfo(const ImageInfo*, Image*);
+	QuantumInfo* AcquireQuantumInfo(const(ImageInfo)*, Image*);
 	QuantumInfo* DestroyQuantumInfo(QuantumInfo*);
 
 	QuantumType GetQuantumType(Image*, ExceptionInfo*);
 
-	size_t ExportQuantumPixels(const Image*, const CacheView*, const QuantumInfo*, const QuantumType, ubyte*, ExceptionInfo*);
-	size_t GetQuantumExtent(const Image*, const QuantumInfo*, const QuantumType);
-	size_t ImportQuantumPixels(Image*, CacheView*, const QuantumInfo*, const QuantumType, const ubyte*, ExceptionInfo*);
+	size_t ExportQuantumPixels(const(Image)*, const(CacheView)*, const(QuantumInfo)*, const QuantumType, ubyte*, ExceptionInfo*);
+	size_t GetQuantumExtent(const(Image)*, const(QuantumInfo)*, const QuantumType);
+	size_t ImportQuantumPixels(Image*, CacheView*, const(QuantumInfo)*, const QuantumType, const(ubyte)*, ExceptionInfo*);
 
-	ubyte* GetQuantumPixels(const QuantumInfo*);
+	ubyte* GetQuantumPixels(const(QuantumInfo)*);
 
-	void GetQuantumInfo(const ImageInfo*, QuantumInfo*);
+	void GetQuantumInfo(const(ImageInfo)*, QuantumInfo*);
 	void SetQuantumAlphaType(QuantumInfo*, const QuantumAlphaType);
 	void SetQuantumImageType(Image*, const QuantumType);
 	void SetQuantumMinIsWhite(QuantumInfo*, const MagickBooleanType);
diff --git a/dmagick/c/registry.d b/dmagick/c/registry.d
index 38ae2fe..d8b528c 100644
--- a/dmagick/c/registry.d
+++ b/dmagick/c/registry.d
@@ -15,13 +15,13 @@ extern(C)
 
 	char* GetNextImageRegistry();
 
-	MagickBooleanType DefineImageRegistry(const RegistryType, const char*, ExceptionInfo*);
-	MagickBooleanType DeleteImageRegistry(const char*);
+	MagickBooleanType DefineImageRegistry(const RegistryType, const(char)*, ExceptionInfo*);
+	MagickBooleanType DeleteImageRegistry(const(char)*);
 	MagickBooleanType RegistryComponentGenesis();
-	MagickBooleanType SetImageRegistry(const RegistryType, const char*, const void*, ExceptionInfo*);
+	MagickBooleanType SetImageRegistry(const RegistryType, const(char)*, const(void)*, ExceptionInfo*);
 
-	void* GetImageRegistry(const RegistryType, const char*, ExceptionInfo*);
+	void* GetImageRegistry(const RegistryType, const(char)*, ExceptionInfo*);
 	void  RegistryComponentTerminus();
-	void* RemoveImageRegistry(const char*);
+	void* RemoveImageRegistry(const(char)*);
 	void  ResetImageRegistryIterator();
 }
diff --git a/dmagick/c/resample.d b/dmagick/c/resample.d
index 77fc6b1..7a0cb0b 100644
--- a/dmagick/c/resample.d
+++ b/dmagick/c/resample.d
@@ -57,7 +57,7 @@ extern(C)
 	MagickBooleanType SetResampleFilterInterpolateMethod(ResampleFilter*, const InterpolatePixelMethod);
 	MagickBooleanType SetResampleFilterVirtualPixelMethod(ResampleFilter*, const VirtualPixelMethod);
 
-	ResampleFilter* AcquireResampleFilter(const Image*, ExceptionInfo*);
+	ResampleFilter* AcquireResampleFilter(const(Image)*, ExceptionInfo*);
 	ResampleFilter* DestroyResampleFilter(ResampleFilter*);
 
 	void ScaleResampleFilter(ResampleFilter*, const double, const double, const double, const double);
diff --git a/dmagick/c/resize.d b/dmagick/c/resize.d
index 7a4aaba..ccf06ca 100644
--- a/dmagick/c/resize.d
+++ b/dmagick/c/resize.d
@@ -6,13 +6,13 @@ import dmagick.c.resample;
 
 extern(C)
 {
-	Image* AdaptiveResizeImage(const Image*, const size_t, const size_t, ExceptionInfo*);
-	Image* LiquidRescaleImage(const Image*, const size_t, const size_t, const double, const double, ExceptionInfo*);
-	Image* MagnifyImage(const Image*, ExceptionInfo*);
-	Image* MinifyImage(const Image*, ExceptionInfo*);
-	Image* ResampleImage(const Image*, const double, const double, const FilterTypes, const double, ExceptionInfo*);
-	Image* ResizeImage(const Image*, const size_t, const size_t, const FilterTypes, const double, ExceptionInfo*);
-	Image* SampleImage(const Image*, const size_t, const size_t, ExceptionInfo*);
-	Image* ScaleImage(const Image*, const size_t, const size_t, ExceptionInfo*);
-	Image* ThumbnailImage(const Image*, const size_t, const size_t, ExceptionInfo*);
+	Image* AdaptiveResizeImage(const(Image)*, const size_t, const size_t, ExceptionInfo*);
+	Image* LiquidRescaleImage(const(Image)*, const size_t, const size_t, const double, const double, ExceptionInfo*);
+	Image* MagnifyImage(const(Image)*, ExceptionInfo*);
+	Image* MinifyImage(const(Image)*, ExceptionInfo*);
+	Image* ResampleImage(const(Image)*, const double, const double, const FilterTypes, const double, ExceptionInfo*);
+	Image* ResizeImage(const(Image)*, const size_t, const size_t, const FilterTypes, const double, ExceptionInfo*);
+	Image* SampleImage(const(Image)*, const size_t, const size_t, ExceptionInfo*);
+	Image* ScaleImage(const(Image)*, const size_t, const size_t, ExceptionInfo*);
+	Image* ThumbnailImage(const(Image)*, const size_t, const size_t, ExceptionInfo*);
 }
diff --git a/dmagick/c/resource.d b/dmagick/c/resource.d
index 1e97a59..f9f92f6 100644
--- a/dmagick/c/resource.d
+++ b/dmagick/c/resource.d
@@ -24,7 +24,7 @@ extern(C)
 
 	MagickBooleanType AcquireMagickResource(const ResourceType, const MagickSizeType);
 	MagickBooleanType ListMagickResourceInfo(FILE*, ExceptionInfo*);
-	MagickBooleanType RelinquishUniqueFileResource(const char*);
+	MagickBooleanType RelinquishUniqueFileResource(const(char)*);
 	MagickBooleanType ResourceComponentGenesis();
 	MagickBooleanType SetMagickResourceLimit(const ResourceType, const MagickSizeType);
 
diff --git a/dmagick/c/segment.d b/dmagick/c/segment.d
index 3f04bfa..85d2c5a 100644
--- a/dmagick/c/segment.d
+++ b/dmagick/c/segment.d
@@ -8,6 +8,6 @@ import dmagick.c.pixel;
 
 extern(C)
 {
-	MagickBooleanType GetImageDynamicThreshold(const Image*, const double, const double, MagickPixelPacket*, ExceptionInfo*);
+	MagickBooleanType GetImageDynamicThreshold(const(Image)*, const double, const double, MagickPixelPacket*, ExceptionInfo*);
 	MagickBooleanType SegmentImage(Image*, const ColorspaceType, const MagickBooleanType, const double, const double);
 }
diff --git a/dmagick/c/sheer.d b/dmagick/c/sheer.d
index 6555e65..fd53fb1 100644
--- a/dmagick/c/sheer.d
+++ b/dmagick/c/sheer.d
@@ -6,8 +6,8 @@ import dmagick.c.image;
 
 extern(C)
 {
-	Image* AffineTransformImage(const Image*, const AffineMatrix*, ExceptionInfo*);
-	Image* DeskewImage(const Image*, const double, ExceptionInfo*);
-	Image* RotateImage(const Image*, const double, ExceptionInfo*);
-	Image* ShearImage(const Image*, const double, const double, ExceptionInfo*);
+	Image* AffineTransformImage(const(Image)*, const(AffineMatrix)*, ExceptionInfo*);
+	Image* DeskewImage(const(Image)*, const double, ExceptionInfo*);
+	Image* RotateImage(const(Image)*, const double, ExceptionInfo*);
+	Image* ShearImage(const(Image)*, const double, const double, ExceptionInfo*);
 }
diff --git a/dmagick/c/splayTree.d b/dmagick/c/splayTree.d
index 69451bd..5a49b08 100644
--- a/dmagick/c/splayTree.d
+++ b/dmagick/c/splayTree.d
@@ -6,25 +6,25 @@ extern(C)
 {
 	struct SplayTreeInfo {}
 
-	MagickBooleanType AddValueToSplayTree(SplayTreeInfo*, const void*, const void*);
-	MagickBooleanType DeleteNodeByValueFromSplayTree(SplayTreeInfo*, const void*);
-	MagickBooleanType DeleteNodeFromSplayTree(SplayTreeInfo*, const void*);
+	MagickBooleanType AddValueToSplayTree(SplayTreeInfo*, const(void)*, const(void)*);
+	MagickBooleanType DeleteNodeByValueFromSplayTree(SplayTreeInfo*, const(void)*);
+	MagickBooleanType DeleteNodeFromSplayTree(SplayTreeInfo*, const(void)*);
 
 	const(void)* GetNextKeyInSplayTree(SplayTreeInfo*);
 	const(void)* GetNextValueInSplayTree(SplayTreeInfo*);
-	const(void)* GetValueFromSplayTree(SplayTreeInfo*, const void*);
+	const(void)* GetValueFromSplayTree(SplayTreeInfo*, const(void)*);
 
-	int CompareSplayTreeString(const void*, const void*);
-	int CompareSplayTreeStringInfo(const void*, const void*);
+	int CompareSplayTreeString(const(void)*, const(void)*);
+	int CompareSplayTreeStringInfo(const(void)*, const(void)*);
 
 	SplayTreeInfo* CloneSplayTree(SplayTreeInfo*, void* function(void*), void* function(void*));
 	SplayTreeInfo* DestroySplayTree(SplayTreeInfo*);
-	SplayTreeInfo* NewSplayTree(int function(const void*, const void*), void* function(void*), void* function(void*));
+	SplayTreeInfo* NewSplayTree(int function(const(void)*, const(void)*), void* function(void*), void* function(void*));
 
-	size_t GetNumberOfNodesInSplayTree(const SplayTreeInfo*);
+	size_t GetNumberOfNodesInSplayTree(const(SplayTreeInfo)*);
 
-	void* RemoveNodeByValueFromSplayTree(SplayTreeInfo*, const void*);
-	void* RemoveNodeFromSplayTree(SplayTreeInfo*, const void*);
+	void* RemoveNodeByValueFromSplayTree(SplayTreeInfo*, const(void)*);
+	void* RemoveNodeFromSplayTree(SplayTreeInfo*, const(void)*);
 	void  ResetSplayTree(SplayTreeInfo*);
 	void  ResetSplayTreeIterator(SplayTreeInfo*);
 }
diff --git a/dmagick/c/statistic.d b/dmagick/c/statistic.d
index b63a184..fba4c5e 100644
--- a/dmagick/c/statistic.d
+++ b/dmagick/c/statistic.d
@@ -67,20 +67,20 @@ extern(C)
 		ArctanFunction
 	}
 
-	ChannelStatistics* GetImageChannelStatistics(const Image*, ExceptionInfo*);
+	ChannelStatistics* GetImageChannelStatistics(const(Image)*, ExceptionInfo*);
 
-	Image* EvaluateImages(const Image*, const MagickEvaluateOperator, ExceptionInfo*);
+	Image* EvaluateImages(const(Image)*, const MagickEvaluateOperator, ExceptionInfo*);
 
 	MagickBooleanType EvaluateImage(Image*, const MagickEvaluateOperator, const double, ExceptionInfo*);
 	MagickBooleanType EvaluateImageChannel(Image*, const ChannelType, const MagickEvaluateOperator, const double, ExceptionInfo*);
-	MagickBooleanType FunctionImage(Image*, const MagickFunction, const size_t, const double*, ExceptionInfo*);
-	MagickBooleanType FunctionImageChannel(Image*, const ChannelType, const MagickFunction, const size_t, const double*, ExceptionInfo*);
-	MagickBooleanType GetImageChannelExtrema(const Image*, const ChannelType, size_t*, size_t*, ExceptionInfo*);
-	MagickBooleanType GetImageChannelMean(const Image*, const ChannelType, double*, double*, ExceptionInfo*);
-	MagickBooleanType GetImageChannelKurtosis(const Image*, const ChannelType, double*, double*, ExceptionInfo*);
-	MagickBooleanType GetImageChannelRange(const Image*, const ChannelType, double*, double*, ExceptionInfo*);
-	MagickBooleanType GetImageExtrema(const Image*, size_t*, size_t*, ExceptionInfo*);
-	MagickBooleanType GetImageRange(const Image*, double*, double*, ExceptionInfo*);
-	MagickBooleanType GetImageMean(const Image*, double*, double*, ExceptionInfo*);
-	MagickBooleanType GetImageKurtosis(const Image*, double*, double*, ExceptionInfo*);
+	MagickBooleanType FunctionImage(Image*, const MagickFunction, const size_t, const(double)*, ExceptionInfo*);
+	MagickBooleanType FunctionImageChannel(Image*, const ChannelType, const MagickFunction, const size_t, const(double)*, ExceptionInfo*);
+	MagickBooleanType GetImageChannelExtrema(const(Image)*, const ChannelType, size_t*, size_t*, ExceptionInfo*);
+	MagickBooleanType GetImageChannelMean(const(Image)*, const ChannelType, double*, double*, ExceptionInfo*);
+	MagickBooleanType GetImageChannelKurtosis(const(Image)*, const ChannelType, double*, double*, ExceptionInfo*);
+	MagickBooleanType GetImageChannelRange(const(Image)*, const ChannelType, double*, double*, ExceptionInfo*);
+	MagickBooleanType GetImageExtrema(const(Image)*, size_t*, size_t*, ExceptionInfo*);
+	MagickBooleanType GetImageRange(const(Image)*, double*, double*, ExceptionInfo*);
+	MagickBooleanType GetImageMean(const(Image)*, double*, double*, ExceptionInfo*);
+	MagickBooleanType GetImageKurtosis(const(Image)*, double*, double*, ExceptionInfo*);
 }
diff --git a/dmagick/c/stream.d b/dmagick/c/stream.d
index 788ca72..bbb288d 100644
--- a/dmagick/c/stream.d
+++ b/dmagick/c/stream.d
@@ -6,9 +6,9 @@ import dmagick.c.magickType;
 
 extern(C)
 {
-	alias size_t function(const Image *,const void *,const size_t) StreamHandler;
+	alias size_t function(const(Image)*, const(void)*, const size_t) StreamHandler;
 
-	Image* ReadStream(const ImageInfo*, StreamHandler, ExceptionInfo*);
+	Image* ReadStream(const(ImageInfo)*, StreamHandler, ExceptionInfo*);
 
-	MagickBooleanType WriteStream(const ImageInfo*, Image*, StreamHandler);
+	MagickBooleanType WriteStream(const(ImageInfo)*, Image*, StreamHandler);
 }
diff --git a/dmagick/c/threshold.d b/dmagick/c/threshold.d
index 4134b13..861bcdf 100644
--- a/dmagick/c/threshold.d
+++ b/dmagick/c/threshold.d
@@ -11,24 +11,24 @@ extern(C)
 {
 	struct ThresholdMap {}
 
-	Image* AdaptiveThresholdImage(const Image*, const size_t, const size_t, const ssize_t, ExceptionInfo*);
+	Image* AdaptiveThresholdImage(const(Image)*, const size_t, const size_t, const ssize_t, ExceptionInfo*);
 
 	ThresholdMap* DestroyThresholdMap(ThresholdMap*);
-	ThresholdMap* GetThresholdMap(const char*, ExceptionInfo*);
+	ThresholdMap* GetThresholdMap(const(char)*, ExceptionInfo*);
 
 	MagickBooleanType BilevelImage(Image*, const double);
 	MagickBooleanType BilevelImageChannel(Image*, const ChannelType, const double);
-	MagickBooleanType BlackThresholdImage(Image*, const char*);
-	MagickBooleanType BlackThresholdImageChannel(Image*, const ChannelType, const char*, ExceptionInfo*);
+	MagickBooleanType BlackThresholdImage(Image*, const(char)*);
+	MagickBooleanType BlackThresholdImageChannel(Image*, const ChannelType, const(char)*, ExceptionInfo*);
 	MagickBooleanType ClampImage(Image*);
 	MagickBooleanType ClampImageChannel(Image*, const ChannelType);
 	MagickBooleanType ListThresholdMaps(FILE*, ExceptionInfo*);
 	MagickBooleanType OrderedDitherImage(Image*);
 	MagickBooleanType OrderedDitherImageChannel(Image*, const ChannelType, ExceptionInfo*);
-	MagickBooleanType OrderedPosterizeImage(Image*, const char*, ExceptionInfo*);
-	MagickBooleanType OrderedPosterizeImageChannel(Image*, const ChannelType, const char*, ExceptionInfo*);
-	MagickBooleanType RandomThresholdImage(Image*, const char*, ExceptionInfo*);
-	MagickBooleanType RandomThresholdImageChannel(Image*, const ChannelType, const char*, ExceptionInfo*);
-	MagickBooleanType WhiteThresholdImage(Image*, const char*);
-	MagickBooleanType WhiteThresholdImageChannel(Image *,const ChannelType,const char *,ExceptionInfo *);
+	MagickBooleanType OrderedPosterizeImage(Image*, const(char)*, ExceptionInfo*);
+	MagickBooleanType OrderedPosterizeImageChannel(Image*, const ChannelType, const(char)*, ExceptionInfo*);
+	MagickBooleanType RandomThresholdImage(Image*, const(char)*, ExceptionInfo*);
+	MagickBooleanType RandomThresholdImageChannel(Image*, const ChannelType, const(char)*, ExceptionInfo*);
+	MagickBooleanType WhiteThresholdImage(Image*, const(char)*);
+	MagickBooleanType WhiteThresholdImageChannel(Image*, const ChannelType, const(char)*, ExceptionInfo *);
 }
diff --git a/dmagick/c/token.d b/dmagick/c/token.d
index 007cc98..b5371cc 100644
--- a/dmagick/c/token.d
+++ b/dmagick/c/token.d
@@ -6,14 +6,14 @@ extern(C)
 {
 	struct TokenInfo {}
 
-	int Tokenizer(TokenInfo*, const uint, char*, const size_t, const char*,
-			const char*, const char*, const char*, const char, char*, int*, char*);
+	int Tokenizer(TokenInfo*, const uint, char*, const size_t, const(char)*,
+			const(char)*, const(char)*, const(char)*, const char, char*, int*, char*);
 
-	MagickBooleanType GlobExpression(const char*, const char*, const MagickBooleanType);
-	MagickBooleanType IsGlob(const char*);
+	MagickBooleanType GlobExpression(const(char)*, const(char)*, const MagickBooleanType);
+	MagickBooleanType IsGlob(const(char)*);
 
 	TokenInfo* AcquireTokenInfo();
 	TokenInfo* DestroyTokenInfo(TokenInfo*);
 
-	void GetMagickToken(const char*, const char**, char*);
+	void GetMagickToken(const(char)*, const(char)**, char*);
 }
diff --git a/dmagick/c/transform.d b/dmagick/c/transform.d
index 462d1a9..ff99106 100644
--- a/dmagick/c/transform.d
+++ b/dmagick/c/transform.d
@@ -9,20 +9,20 @@ import dmagick.c.magickType;
 
 extern(C)
 {
-	Image* ChopImage(const Image*, const RectangleInfo*, ExceptionInfo*);
-	Image* ConsolidateCMYKImages(const Image*, ExceptionInfo*);
-	Image* CropImage(const Image*, const RectangleInfo*, ExceptionInfo*);
-	Image* ExcerptImage(const Image*, const RectangleInfo*, ExceptionInfo*);
-	Image* ExtentImage(const Image*, const RectangleInfo*, ExceptionInfo*);
-	Image* FlipImage(const Image*, ExceptionInfo*);
-	Image* FlopImage(const Image*, ExceptionInfo*);
-	Image* RollImage(const Image*, const ssize_t, const ssize_t, ExceptionInfo*);
-	Image* ShaveImage(const Image*, const RectangleInfo*, ExceptionInfo*);
-	Image* SpliceImage(const Image*, const RectangleInfo*, ExceptionInfo*);
-	Image* TransposeImage(const Image*, ExceptionInfo*);
-	Image* TransverseImage(const Image*, ExceptionInfo*);
-	Image* TrimImage(const Image*, ExceptionInfo*);
+	Image* ChopImage(const(Image)*, const(RectangleInfo)*, ExceptionInfo*);
+	Image* ConsolidateCMYKImages(const(Image)*, ExceptionInfo*);
+	Image* CropImage(const(Image)*, const(RectangleInfo)*, ExceptionInfo*);
+	Image* ExcerptImage(const(Image)*, const(RectangleInfo)*, ExceptionInfo*);
+	Image* ExtentImage(const(Image)*, const(RectangleInfo)*, ExceptionInfo*);
+	Image* FlipImage(const(Image)*, ExceptionInfo*);
+	Image* FlopImage(const(Image)*, ExceptionInfo*);
+	Image* RollImage(const(Image)*, const ssize_t, const ssize_t, ExceptionInfo*);
+	Image* ShaveImage(const(Image)*, const(RectangleInfo)*, ExceptionInfo*);
+	Image* SpliceImage(const(Image)*, const(RectangleInfo)*, ExceptionInfo*);
+	Image* TransposeImage(const(Image)*, ExceptionInfo*);
+	Image* TransverseImage(const(Image)*, ExceptionInfo*);
+	Image* TrimImage(const(Image)*, ExceptionInfo*);
 
-	MagickBooleanType TransformImage(Image**, const char*, const char*);
-	MagickBooleanType TransformImages(Image**, const char*, const char*);
+	MagickBooleanType TransformImage(Image**, const(char)*, const(char)*);
+	MagickBooleanType TransformImages(Image**, const(char)*, const(char)*);
 }
diff --git a/dmagick/c/type.d b/dmagick/c/type.d
index 61c76dd..0291b18 100644
--- a/dmagick/c/type.d
+++ b/dmagick/c/type.d
@@ -69,14 +69,14 @@ extern(C)
 			signature;
 	}
 
-	char** GetTypeList(const char*, size_t*, ExceptionInfo*);
+	char** GetTypeList(const(char)*, size_t*, ExceptionInfo*);
 
 	MagickBooleanType ListTypeInfo(FILE*, ExceptionInfo*);
 	MagickBooleanType TypeComponentGenesis();
 
-	const(TypeInfo)*  GetTypeInfo(const char*, ExceptionInfo*);
-	const(TypeInfo)*  GetTypeInfoByFamily(const char*, const StyleType, const StretchType, const size_t, ExceptionInfo*);
-	const(TypeInfo)** GetTypeInfoList(const char*, size_t*, ExceptionInfo*);
+	const(TypeInfo)*  GetTypeInfo(const(char)*, ExceptionInfo*);
+	const(TypeInfo)*  GetTypeInfoByFamily(const(char)*, const StyleType, const StretchType, const size_t, ExceptionInfo*);
+	const(TypeInfo)** GetTypeInfoList(const(char)*, size_t*, ExceptionInfo*);
 
 	void TypeComponentTerminus();
 }
diff --git a/dmagick/c/utility.d b/dmagick/c/utility.d
index bc4e2db..eb35e44 100644
--- a/dmagick/c/utility.d
+++ b/dmagick/c/utility.d
@@ -21,31 +21,31 @@ extern(C)
 		CanonicalPath
 	}
 
-	char*  Base64Encode(const ubyte*, const size_t, size_t*);
-	char** GetPathComponents(const char*, size_t*);
-	char** ListFiles(const char*, const char*, size_t*);
+	char*  Base64Encode(const(ubyte)*, const size_t, size_t*);
+	char** GetPathComponents(const(char)*, size_t*);
+	char** ListFiles(const(char)*, const(char)*, size_t*);
 
-	FILE* OpenMagickStream(const char*, const char*);
+	FILE* OpenMagickStream(const(char)*, const(char)*);
 
-	int SystemCommand(const MagickBooleanType, const MagickBooleanType, const char*, ExceptionInfo*);
+	int SystemCommand(const MagickBooleanType, const MagickBooleanType, const(char)*, ExceptionInfo*);
 
 	MagickBooleanType AcquireUniqueFilename(char*);
-	MagickBooleanType AcquireUniqueSymbolicLink(const char*, char*);
+	MagickBooleanType AcquireUniqueSymbolicLink(const(char)*, char*);
 	MagickBooleanType ExpandFilenames(int*, char***);
-	MagickBooleanType GetPathAttributes(const char*, void*);
+	MagickBooleanType GetPathAttributes(const(char)*, void*);
 	MagickBooleanType GetExecutionPath(char*, const size_t);
-	MagickBooleanType IsMagickTrue(const char*);
-	MagickBooleanType IsPathAccessible(const char*);
+	MagickBooleanType IsMagickTrue(const(char)*);
+	MagickBooleanType IsPathAccessible(const(char)*);
 
-	size_t MultilineCensus(const char*);
+	size_t MultilineCensus(const(char)*);
 
 	ssize_t GetMagickPageSize();
 
-	ubyte* Base64Decode(const char*, size_t*);
+	ubyte* Base64Decode(const(char)*, size_t*);
 
-	void AppendImageFormat(const char*, char*);
+	void AppendImageFormat(const(char)*, char*);
 	void ChopPathComponents(char*, const size_t);
 	void ExpandFilename(char*);
-	void GetPathComponent(const char*, PathType, char*);
+	void GetPathComponent(const(char)*, PathType, char*);
 	void MagickDelay(const MagickSizeType);
 }
diff --git a/dmagick/c/xmlTree.d b/dmagick/c/xmlTree.d
index 906490d..d3c939b 100644
--- a/dmagick/c/xmlTree.d
+++ b/dmagick/c/xmlTree.d
@@ -8,29 +8,29 @@ extern(C)
 {
 	struct XMLTreeInfo {}
 
-	char* CanonicalXMLContent(const char*, const MagickBooleanType);
+	char* CanonicalXMLContent(const(char)*, const MagickBooleanType);
 	char* XMLTreeInfoToXML(XMLTreeInfo*);
 
-	const(char)*  GetXMLTreeAttribute(XMLTreeInfo*, const char*);
+	const(char)*  GetXMLTreeAttribute(XMLTreeInfo*, const(char)*);
 	const(char)*  GetXMLTreeContent(XMLTreeInfo*);
-	const(char)** GetXMLTreeProcessingInstructions(XMLTreeInfo*, const char*);
+	const(char)** GetXMLTreeProcessingInstructions(XMLTreeInfo*, const(char)*);
 	const(char)*  GetXMLTreeTag(XMLTreeInfo*);
 
-	MagickBooleanType GetXMLTreeAttributes(const XMLTreeInfo*, SplayTreeInfo*);
+	MagickBooleanType GetXMLTreeAttributes(const(XMLTreeInfo)*, SplayTreeInfo*);
 
-	XMLTreeInfo* AddChildToXMLTree(XMLTreeInfo*, const char*, const size_t);
-	XMLTreeInfo* AddPathToXMLTree(XMLTreeInfo*, const char*, const size_t);
+	XMLTreeInfo* AddChildToXMLTree(XMLTreeInfo*, const(char)*, const size_t);
+	XMLTreeInfo* AddPathToXMLTree(XMLTreeInfo*, const(char)*, const size_t);
 	XMLTreeInfo* DestroyXMLTree(XMLTreeInfo*);
 	XMLTreeInfo* GetNextXMLTreeTag(XMLTreeInfo*);
-	XMLTreeInfo* GetXMLTreeChild(XMLTreeInfo*, const char*);
+	XMLTreeInfo* GetXMLTreeChild(XMLTreeInfo*, const(char)*);
 	XMLTreeInfo* GetXMLTreeOrdered(XMLTreeInfo*);
-	XMLTreeInfo* GetXMLTreePath(XMLTreeInfo*, const char*);
+	XMLTreeInfo* GetXMLTreePath(XMLTreeInfo*, const(char)*);
 	XMLTreeInfo* GetXMLTreeSibling(XMLTreeInfo*);
 	XMLTreeInfo* InsertTagIntoXMLTree(XMLTreeInfo*, XMLTreeInfo*, const size_t);
-	XMLTreeInfo* NewXMLTree(const char*, ExceptionInfo*);
-	XMLTreeInfo* NewXMLTreeTag(const char*);
+	XMLTreeInfo* NewXMLTree(const(char)*, ExceptionInfo*);
+	XMLTreeInfo* NewXMLTreeTag(const(char)*);
 	XMLTreeInfo* ParseTagFromXMLTree(XMLTreeInfo*);
 	XMLTreeInfo* PruneTagFromXMLTree(XMLTreeInfo*);
-	XMLTreeInfo* SetXMLTreeAttribute(XMLTreeInfo*, const char*, const char*);
-	XMLTreeInfo* SetXMLTreeContent(XMLTreeInfo*, const char*);
+	XMLTreeInfo* SetXMLTreeAttribute(XMLTreeInfo*, const(char)*, const(char)*);
+	XMLTreeInfo* SetXMLTreeContent(XMLTreeInfo*, const(char)*);
 }
diff --git a/dmagick/c/xwindow.d b/dmagick/c/xwindow.d
index 80b416a..2131311 100644
--- a/dmagick/c/xwindow.d
+++ b/dmagick/c/xwindow.d
@@ -15,7 +15,7 @@ extern(C)
 		silent;
 	}
 
-	Image* XImportImage(const ImageInfo*, XImportInfo*);
+	Image* XImportImage(const(ImageInfo)*, XImportInfo*);
 
 	void XGetImportInfo(XImportInfo*);
 }