initial checkin

84 files changed, 4596 insertions, 0 deletions

diff --git a/dmagick/c/MagickCore.d b/dmagick/c/MagickCore.d
new file mode 100644
index 0000000..b48bcc6
--- /dev/null
+++ b/dmagick/c/MagickCore.d
@@ -0,0 +1,86 @@
+module dmagick.c.MagickCore;
+
+public import dmagick.c.accelerate;
+public import dmagick.c.animate;
+public import dmagick.c.annotate;
+public import dmagick.c.artifact;
+public import dmagick.c.attribute;
+public import dmagick.c.blob;
+public import dmagick.c.cache;
+public import dmagick.c.cacheView;
+public import dmagick.c.cipher;
+public import dmagick.c.client;
+public import dmagick.c.coder;
+public import dmagick.c.color;
+public import dmagick.c.colormap;
+public import dmagick.c.colorspace;
+public import dmagick.c.compare;
+public import dmagick.c.composite;
+public import dmagick.c.compress;
+public import dmagick.c.configure;
+public import dmagick.c.constitute;
+public import dmagick.c.decorate;
+public import dmagick.c.deprecate;
+public import dmagick.c.display;
+public import dmagick.c.distort;
+public import dmagick.c.draw;
+public import dmagick.c.effect;
+public import dmagick.c.enhance;
+public import dmagick.c.exception;
+public import dmagick.c.feature;
+public import dmagick.c.fourier;
+public import dmagick.c.fx;
+public import dmagick.c.gem;
+public import dmagick.c.geometry;
+public import dmagick.c.hashmap;
+public import dmagick.c.histogram;
+public import dmagick.c.identify;
+public import dmagick.c.image;
+public import dmagick.c.imageView;
+public import dmagick.c.layer;
+public import dmagick.c.list;
+public import dmagick.c.locale;
+public import dmagick.c.log;
+public import dmagick.c.magic;
+public import dmagick.c.magick;
+public import dmagick.c.magickDelegate;
+public import dmagick.c.magickModule;
+public import dmagick.c.magickString;
+public import dmagick.c.magickType;
+public import dmagick.c.magickVersion;
+public import dmagick.c.matrix;
+public import dmagick.c.memory;
+public import dmagick.c.mime;
+public import dmagick.c.monitor;
+public import dmagick.c.montage;
+public import dmagick.c.morphology;
+public import dmagick.c.option;
+public import dmagick.c.paint;
+public import dmagick.c.pixel;
+public import dmagick.c.policy;
+public import dmagick.c.prepress;
+public import dmagick.c.profile;
+public import dmagick.c.property;
+public import dmagick.c.quantize;
+public import dmagick.c.quantum;
+public import dmagick.c.random;
+public import dmagick.c.registry;
+public import dmagick.c.resample;
+public import dmagick.c.resize;
+public import dmagick.c.resource;
+public import dmagick.c.segment;
+public import dmagick.c.semaphore;
+public import dmagick.c.sheer;
+public import dmagick.c.signature;
+public import dmagick.c.splayTree;
+public import dmagick.c.statistic;
+public import dmagick.c.stream;
+public import dmagick.c.threshold;
+public import dmagick.c.timer;
+public import dmagick.c.token;
+public import dmagick.c.transform;
+public import dmagick.c.type;
+public import dmagick.c.utility;
+public import dmagick.c.xmlTree;
+public import dmagick.c.xwindow;
+
diff --git a/dmagick/c/accelerate.d b/dmagick/c/accelerate.d
new file mode 100644
index 0000000..ff5c9f0
--- /dev/null
+++ b/dmagick/c/accelerate.d
@@ -0,0 +1,8 @@
+module dmagick.c.accelerate;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.morphology;
+
+extern(C) MagickBooleanType AccelerateConvolveImage(const Image*, const KernelInfo*, Image*, ExceptionInfo*);
diff --git a/dmagick/c/animate.d b/dmagick/c/animate.d
new file mode 100644
index 0000000..3915e55
--- /dev/null
+++ b/dmagick/c/animate.d
@@ -0,0 +1,6 @@
+module dmagick.c.animate;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C) MagickBooleanType AnimateImages(const ImageInfo*, Image*);
diff --git a/dmagick/c/annotate.d b/dmagick/c/annotate.d
new file mode 100644
index 0000000..be4fc45
--- /dev/null
+++ b/dmagick/c/annotate.d
@@ -0,0 +1,16 @@
+module dmagick.c.annotate;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.draw;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	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
new file mode 100644
index 0000000..0899c3d
--- /dev/null
+++ b/dmagick/c/artifact.d
@@ -0,0 +1,20 @@
+module dmagick.c.artifact;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	char* GetNextImageArtifact(const Image*);
+	char* RemoveImageArtifact(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*);
+
+	void DestroyImageArtifacts(Image*);
+	void ResetImageArtifactIterator(const Image*);
+}
diff --git a/dmagick/c/attribute.d b/dmagick/c/attribute.d
new file mode 100644
index 0000000..c827155
--- /dev/null
+++ b/dmagick/c/attribute.d
@@ -0,0 +1,23 @@
+module dmagick.c.attribute;
+
+import dmagick.c.image;
+import dmagick.c.exception;
+import dmagick.c.magickType;
+import dmagick.c.geometry;
+
+extern(C)
+{
+	ImageType GetImageType(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);
+
+	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
new file mode 100644
index 0000000..95f3817
--- /dev/null
+++ b/dmagick/c/blob.d
@@ -0,0 +1,45 @@
+module dmagick.c.blob;
+
+import core.stdc.stdio;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.stream;
+
+extern(C)
+{
+	enum MapMode
+	{
+		ReadMode,
+		WriteMode,
+		IOMode
+	}
+
+	FILE* GetBlobFileHandle(const Image*);
+
+	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 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*);
+
+	MagickSizeType GetBlobSize(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*);
+
+	void DestroyBlob(Image*);
+	void DuplicateBlob(Image*, const Image*);
+	void SetBlobExempt(Image*, const MagickBooleanType);
+}
diff --git a/dmagick/c/cache.d b/dmagick/c/cache.d
new file mode 100644
index 0000000..d696e08
--- /dev/null
+++ b/dmagick/c/cache.d
@@ -0,0 +1,41 @@
+module dmagick.c.cache;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.image;
+import dmagick.c.pixel;
+import dmagick.c.exception;
+import dmagick.c.magickType;
+import dmagick.c.cacheView;
+
+extern(C)
+{
+	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(void*) AcquirePixelCachePixels(const Image*, MagickSizeType*, ExceptionInfo*);
+
+	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 GetOneAuthenticPixel(Image*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
+	MagickBooleanType PersistPixelCache(Image*, const char*, const MagickBooleanType, MagickOffsetType*, ExceptionInfo*);
+	MagickBooleanType SyncAuthenticPixels(Image*, ExceptionInfo*);
+
+	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* 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);
+
+	void  CacheComponentTerminus();
+	void* GetPixelCachePixels(Image*, MagickSizeType*, ExceptionInfo*);
+}
diff --git a/dmagick/c/cacheView.d b/dmagick/c/cacheView.d
new file mode 100644
index 0000000..7d85a46
--- /dev/null
+++ b/dmagick/c/cacheView.d
@@ -0,0 +1,66 @@
+module dmagick.c.cacheView;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.colorspace;
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+
+extern(C)
+{
+	enum VirtualPixelMethod
+	{
+		UndefinedVirtualPixelMethod,
+		BackgroundVirtualPixelMethod,
+		ConstantVirtualPixelMethod,
+		DitherVirtualPixelMethod,
+		EdgeVirtualPixelMethod,
+		MirrorVirtualPixelMethod,
+		RandomVirtualPixelMethod,
+		TileVirtualPixelMethod,
+		TransparentVirtualPixelMethod,
+		MaskVirtualPixelMethod,
+		BlackVirtualPixelMethod,
+		GrayVirtualPixelMethod,
+		WhiteVirtualPixelMethod,
+		HorizontalTileVirtualPixelMethod,
+		VerticalTileVirtualPixelMethod,
+		HorizontalTileEdgeVirtualPixelMethod,
+		VerticalTileEdgeVirtualPixelMethod,
+		CheckerTileVirtualPixelMethod
+	}
+
+	struct CacheView {}
+
+	ClassType GetCacheViewStorageClass(const CacheView*);
+
+	ColorspaceType GetCacheViewColorspace(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*);
+
+	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 SetCacheViewStorageClass(CacheView*, const ClassType);
+	MagickBooleanType SetCacheViewVirtualPixelMethod(CacheView*, const VirtualPixelMethod);
+	MagickBooleanType SyncCacheViewAuthenticPixels(CacheView*, ExceptionInfo*);
+
+	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* DestroyCacheView(CacheView*);
+}
diff --git a/dmagick/c/cipher.d b/dmagick/c/cipher.d
new file mode 100644
index 0000000..be48b7a
--- /dev/null
+++ b/dmagick/c/cipher.d
@@ -0,0 +1,14 @@
+module dmagick.c.cipher;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickString;
+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*);
+}
diff --git a/dmagick/c/client.d b/dmagick/c/client.d
new file mode 100644
index 0000000..4404607
--- /dev/null
+++ b/dmagick/c/client.d
@@ -0,0 +1,9 @@
+module dmagick.c.client;
+
+extern(C)
+{
+	const(char*) GetClientPath();
+	const(char*) GetClientName();
+	const(char*) SetClientName(const char*);
+	const(char*) SetClientPath(const char*);
+}
diff --git a/dmagick/c/coder.d b/dmagick/c/coder.d
new file mode 100644
index 0000000..52f5d32
--- /dev/null
+++ b/dmagick/c/coder.d
@@ -0,0 +1,37 @@
+module dmagick.c.coder;
+
+import core.stdc.stdio;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct CoderInfo
+	{
+		char*
+			path,
+			magick,
+			name;
+
+		MagickBooleanType
+			exempt,
+			stealth;
+
+		CoderInfo*
+			previous,
+			next;
+
+		size_t
+			signature;
+	}
+
+	char** GetCoderList(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*);
+}
+	void CoderComponentTerminus();
diff --git a/dmagick/c/color.d b/dmagick/c/color.d
new file mode 100644
index 0000000..be66bef
--- /dev/null
+++ b/dmagick/c/color.d
@@ -0,0 +1,79 @@
+module dmagick.c.color;
+
+import core.stdc.stdio;
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+
+extern(C)
+{
+	enum ComplianceType
+	{
+		UndefinedCompliance,
+		NoCompliance  = 0x0000,
+		SVGCompliance = 0x0001,
+		X11Compliance = 0x0002,
+		XPMCompliance = 0x0004,
+		AllCompliance = 0x7fffffff
+	}
+
+	struct ColorInfo
+	{
+		char*
+			path,
+			name;
+
+		ComplianceType
+			compliance;
+
+		MagickPixelPacket
+			color;
+
+		MagickBooleanType
+			exempt,
+			stealth;
+
+		ColorInfo*
+			previous,
+			next;
+
+		size_t
+			signature;
+	}
+
+	struct ErrorInfo
+	{
+		double
+			mean_error_per_pixel,
+			normalized_mean_error,
+			normalized_maximum_error;
+	}
+
+	char** GetColorList(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 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*);
+
+	void ColorComponentTerminus();
+	void ConcatenateColorComponent(const MagickPixelPacket*, const ChannelType, const ComplianceType, char*);
+	void GetColorTuple(const MagickPixelPacket*, const MagickBooleanType, char*);
+}
diff --git a/dmagick/c/colormap.d b/dmagick/c/colormap.d
new file mode 100644
index 0000000..12eecb3
--- /dev/null
+++ b/dmagick/c/colormap.d
@@ -0,0 +1,13 @@
+module dmagick.c.colormap;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	MagickBooleanType AcquireImageColormap(Image*, const size_t);
+	MagickBooleanType CycleColormapImage(Image*, const ssize_t);
+	MagickBooleanType SortColormapByIntensity(Image*);
+}
diff --git a/dmagick/c/colorspace.d b/dmagick/c/colorspace.d
new file mode 100644
index 0000000..59d4efd
--- /dev/null
+++ b/dmagick/c/colorspace.d
@@ -0,0 +1,39 @@
+module dmagick.c.colorspace;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum ColorspaceType
+	{
+		UndefinedColorspace,
+		RGBColorspace,
+		GRAYColorspace,
+		TransparentColorspace,
+		OHTAColorspace,
+		LabColorspace,
+		XYZColorspace,
+		YCbCrColorspace,
+		YCCColorspace,
+		YIQColorspace,
+		YPbPrColorspace,
+		YUVColorspace,
+		CMYKColorspace,
+		sRGBColorspace,
+		HSBColorspace,
+		HSLColorspace,
+		HWBColorspace,
+		Rec601LumaColorspace,
+		Rec601YCbCrColorspace,
+		Rec709LumaColorspace,
+		Rec709YCbCrColorspace,
+		LogColorspace,
+		CMYColorspace
+	}
+
+	MagickBooleanType RGBTransformImage(Image*, const ColorspaceType);
+	MagickBooleanType SetImageColorspace(Image*, const ColorspaceType);
+	MagickBooleanType TransformImageColorspace(Image*, const ColorspaceType);
+	MagickBooleanType TransformRGBImage(Image*, const ColorspaceType);
+}
diff --git a/dmagick/c/compare.d b/dmagick/c/compare.d
new file mode 100644
index 0000000..b2a755f
--- /dev/null
+++ b/dmagick/c/compare.d
@@ -0,0 +1,31 @@
+module dmagick.c.compare;
+
+import dmagick.c.exception;
+import dmagick.c.geometry;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum MetricType
+	{
+		UndefinedMetric,
+		AbsoluteErrorMetric,
+		MeanAbsoluteErrorMetric,
+		MeanErrorPerPixelMetric,
+		MeanSquaredErrorMetric,
+		PeakAbsoluteErrorMetric,
+		PeakSignalToNoiseRatioMetric,
+		RootMeanSquaredErrorMetric
+	}
+
+	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*);
+
+	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
new file mode 100644
index 0000000..e280fc8
--- /dev/null
+++ b/dmagick/c/composite.d
@@ -0,0 +1,81 @@
+module dmagick.c.composite;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum CompositeOperator
+	{
+		UndefinedCompositeOp,
+		NoCompositeOp,
+		ModulusAddCompositeOp,
+		AtopCompositeOp,
+		BlendCompositeOp,
+		BumpmapCompositeOp,
+		ChangeMaskCompositeOp,
+		ClearCompositeOp,
+		ColorBurnCompositeOp,
+		ColorDodgeCompositeOp,
+		ColorizeCompositeOp,
+		CopyBlackCompositeOp,
+		CopyBlueCompositeOp,
+		CopyCompositeOp,
+		CopyCyanCompositeOp,
+		CopyGreenCompositeOp,
+		CopyMagentaCompositeOp,
+		CopyOpacityCompositeOp,
+		CopyRedCompositeOp,
+		CopyYellowCompositeOp,
+		DarkenCompositeOp,
+		DstAtopCompositeOp,
+		DstCompositeOp,
+		DstInCompositeOp,
+		DstOutCompositeOp,
+		DstOverCompositeOp,
+		DifferenceCompositeOp,
+		DisplaceCompositeOp,
+		DissolveCompositeOp,
+		ExclusionCompositeOp,
+		HardLightCompositeOp,
+		HueCompositeOp,
+		InCompositeOp,
+		LightenCompositeOp,
+		LinearLightCompositeOp,
+		LuminizeCompositeOp,
+		MinusCompositeOp,
+		ModulateCompositeOp,
+		MultiplyCompositeOp,
+		OutCompositeOp,
+		OverCompositeOp,
+		OverlayCompositeOp,
+		PlusCompositeOp,
+		ReplaceCompositeOp,
+		SaturateCompositeOp,
+		ScreenCompositeOp,
+		SoftLightCompositeOp,
+		SrcAtopCompositeOp,
+		SrcCompositeOp,
+		SrcInCompositeOp,
+		SrcOutCompositeOp,
+		SrcOverCompositeOp,
+		ModulusSubtractCompositeOp,
+		ThresholdCompositeOp,
+		XorCompositeOp,
+		DivideCompositeOp,
+		DistortCompositeOp,
+		BlurCompositeOp,
+		PegtopLightCompositeOp,
+		VividLightCompositeOp,
+		PinLightCompositeOp,
+		LinearDodgeCompositeOp,
+		LinearBurnCompositeOp,
+		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*);
+}
diff --git a/dmagick/c/compress.d b/dmagick/c/compress.d
new file mode 100644
index 0000000..bee6bfa
--- /dev/null
+++ b/dmagick/c/compress.d
@@ -0,0 +1,42 @@
+module dmagick.c.compress;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum CompressionType
+	{
+		UndefinedCompression,
+		NoCompression,
+		BZipCompression,
+		DXT1Compression,
+		DXT3Compression,
+		DXT5Compression,
+		FaxCompression,
+		Group4Compression,
+		JPEGCompression,
+		JPEG2000Compression,
+		LosslessJPEGCompression,
+		LZWCompression,
+		RLECompression,
+		ZipCompression,
+		ZipSCompression,
+		PizCompression,
+		Pxr24Compression,
+		B44Compression,
+		B44ACompression
+	}
+
+	struct Ascii85Info {}
+
+	MagickBooleanType HuffmanDecodeImage(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*);
+
+	void Ascii85Encode(Image*, const ubyte);
+	void Ascii85Flush(Image*);
+	void Ascii85Initialize(Image*);
+}
diff --git a/dmagick/c/configure.d b/dmagick/c/configure.d
new file mode 100644
index 0000000..ffd7942
--- /dev/null
+++ b/dmagick/c/configure.d
@@ -0,0 +1,46 @@
+module dmagick.c.configure;
+
+import core.stdc.stdio;
+
+import dmagick.c.exception;
+import dmagick.c.hashmap;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct ConfigureInfo
+	{
+		char*
+			path,
+			name,
+			value;
+
+		MagickBooleanType
+			exempt,
+			stealth;
+
+		ConfigureInfo*
+			previous,
+			next;
+
+		size_t
+			signature;
+	}
+
+	char** GetConfigureList(const char*, size_t*, ExceptionInfo*);
+	char*  GetConfigureOption(const char*);
+
+	const(char*) GetConfigureValue(const ConfigureInfo*);
+
+	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 *);
+
+	MagickBooleanType ConfigureComponentGenesis();
+	MagickBooleanType ListConfigureInfo(FILE*, ExceptionInfo*);
+
+	void ConfigureComponentTerminus();
+}
diff --git a/dmagick/c/constitute.d b/dmagick/c/constitute.d
new file mode 100644
index 0000000..ddf3de7
--- /dev/null
+++ b/dmagick/c/constitute.d
@@ -0,0 +1,33 @@
+module dmagick.c.constitute;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum StorageType
+	{
+		UndefinedPixel,
+		CharPixel,
+		DoublePixel,
+		FloatPixel,
+		IntegerPixel,
+		LongPixel,
+		QuantumPixel,
+		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*);
+
+	MagickBooleanType ConstituteComponentGenesis();
+	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
new file mode 100644
index 0000000..7aa15f1
--- /dev/null
+++ b/dmagick/c/decorate.d
@@ -0,0 +1,29 @@
+module dmagick.c.decorate;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.geometry;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct FrameInfo
+	{
+		size_t
+			width,
+			height;
+
+		ssize_t
+			x,
+			y,
+			inner_bevel,
+			outer_bevel;
+	}
+
+	Image* BorderImage(const Image*, const RectangleInfo*, ExceptionInfo*);
+	Image* FrameImage(const Image*, const FrameInfo*, ExceptionInfo*);
+
+	MagickBooleanType RaiseImage(Image*, const RectangleInfo*, const MagickBooleanType);
+}
diff --git a/dmagick/c/deprecate.d b/dmagick/c/deprecate.d
new file mode 100644
index 0000000..e68cc5e
--- /dev/null
+++ b/dmagick/c/deprecate.d
@@ -0,0 +1,193 @@
+module dmagick.c.deprecate;
+
+import core.vararg;
+import core.stdc.stdio;
+import core.sys.posix.sys.types;
+
+import dmagick.c.cacheView;
+import dmagick.c.colorspace;
+import dmagick.c.constitute;
+import dmagick.c.draw;
+import dmagick.c.exception;
+import dmagick.c.geometry;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+import dmagick.c.quantize;
+import dmagick.c.quantum;
+import dmagick.c.registry;
+import dmagick.c.resample;
+import dmagick.c.semaphore;
+
+deprecated extern(C)
+{
+	enum MagickLayerMethod
+	{
+		UndefinedMagickLayerMethod
+	}
+
+	alias MagickOffsetType ExtendedSignedIntegralType;
+	alias MagickSizeType   ExtendedUnsignedIntegralType;
+	alias MagickRealType   ExtendedRationalType;
+
+	struct ViewInfo {}
+
+	alias MagickBooleanType function(const char*, const MagickOffsetType, const MagickSizeType, ExceptionInfo*) MonitorHandler;
+
+	struct ImageAttribute
+	{
+		char*
+			key,
+			value;
+
+		MagickBooleanType
+			compression;
+
+		ImageAttribute*
+			previous,
+			next;
+	}
+
+	CacheView* CloseCacheView(CacheView*);
+	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 *);
+
+	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*);
+	Image* FlattenImages(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* 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*);
+
+	IndexPacket* GetCacheViewIndexes(CacheView*);
+	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*);
+
+	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 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 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 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 SetExceptionInfo(ExceptionInfo*, ExceptionType);
+	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*);
+
+	MonitorHandler GetMonitorHandler();
+	MonitorHandler SetMonitorHandler(MonitorHandler);
+
+	MagickOffsetType SizeBlob(Image* image);
+
+	MagickPixelPacket InterpolatePixelColor(const Image*, CacheView*, const InterpolatePixelMethod, const double, const double, ExceptionInfo*);
+
+	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* 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* 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 PopImagePixels(Image*, const QuantumType, ubyte*);
+	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 QuantizationError(Image*);
+	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*);
+
+	void* AcquireMemory(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* 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  HSLTransform(const double, const double, const double, Quantum*, Quantum*, Quantum*);
+	void  InitializeMagick(const char*);
+	void  MagickIncarnate(const char*);
+	void  ReacquireMemory(void**, const size_t);
+	void  ResetImageAttributeIterator(const Image*);
+	void  SetCacheThreshold(const size_t);
+	void  SetImage(Image*, const Quantum);
+	void  Strip(char*);
+	void  TemporaryFilename(char*);
+	void  TransformHSL(const Quantum, const Quantum, const Quantum, double*, double*, double*);
+}
diff --git a/dmagick/c/display.d b/dmagick/c/display.d
new file mode 100644
index 0000000..3b11356
--- /dev/null
+++ b/dmagick/c/display.d
@@ -0,0 +1,11 @@
+module dmagick.c.display;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	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
new file mode 100644
index 0000000..bb32224
--- /dev/null
+++ b/dmagick/c/distort.d
@@ -0,0 +1,43 @@
+module dmagick.c.distort;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum DistortImageMethod
+	{
+		UndefinedDistortion,
+		AffineDistortion,
+		AffineProjectionDistortion,
+		ScaleRotateTranslateDistortion,
+		PerspectiveDistortion,
+		PerspectiveProjectionDistortion,
+		BilinearForwardDistortion,
+		BilinearDistortion = BilinearForwardDistortion,
+		BilinearReverseDistortion,
+		PolynomialDistortion,
+		ArcDistortion,
+		PolarDistortion,
+		DePolarDistortion,
+		BarrelDistortion,
+		BarrelInverseDistortion,
+		ShepardsDistortion,
+		SentinelDistortion
+	}
+
+	enum SparseColorMethod
+	{
+		UndefinedColorInterpolate =   DistortImageMethod.UndefinedDistortion,
+		BarycentricColorInterpolate = DistortImageMethod.AffineDistortion,
+		BilinearColorInterpolate =    DistortImageMethod.BilinearReverseDistortion,
+		PolynomialColorInterpolate =  DistortImageMethod.PolynomialDistortion,
+		ShepardsColorInterpolate =    DistortImageMethod.ShepardsDistortion,
+
+		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*);
+}
diff --git a/dmagick/c/draw.d b/dmagick/c/draw.d
new file mode 100644
index 0000000..7032abe
--- /dev/null
+++ b/dmagick/c/draw.d
@@ -0,0 +1,369 @@
+module dmagick.c.draw;
+
+import dmagick.c.composite;
+import dmagick.c.geometry;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+import dmagick.c.type;
+
+extern(C)
+{
+	enum AlignType
+	{
+		UndefinedAlign,
+		LeftAlign,
+		CenterAlign,
+		RightAlign
+	}
+
+	enum ClipPathUnits
+	{
+		UndefinedPathUnits,
+		UserSpace,
+		UserSpaceOnUse,
+		ObjectBoundingBox
+	}
+
+	enum DecorationType
+	{
+		UndefinedDecoration,
+		NoDecoration,
+		UnderlineDecoration,
+		OverlineDecoration,
+		LineThroughDecoration
+	}
+
+	enum DirectionType
+	{
+		UndefinedDirection,
+		RightToLeftDirection,
+		LeftToRightDirection
+	}
+
+	enum FillRule
+	{
+		UndefinedRule,
+
+		EvenOddRule,
+		NonZeroRule
+	}
+
+	enum GradientType
+	{
+		UndefinedGradient,
+		LinearGradient,
+		RadialGradient
+	}
+
+	enum LineCap
+	{
+		UndefinedCap,
+		ButtCap,
+		RoundCap,
+		SquareCap
+	}
+
+	enum LineJoin
+	{
+		UndefinedJoin,
+		MiterJoin,
+		RoundJoin,
+		BevelJoin
+	}
+
+	enum PaintMethod
+	{
+		UndefinedMethod,
+		PointMethod,
+		ReplaceMethod,
+		FloodfillMethod,
+		FillToBorderMethod,
+		ResetMethod
+	}
+
+	enum PrimitiveType
+	{
+		UndefinedPrimitive,
+		PointPrimitive,
+		LinePrimitive,
+		RectanglePrimitive,
+		RoundRectanglePrimitive,
+		ArcPrimitive,
+		EllipsePrimitive,
+		CirclePrimitive,
+		PolylinePrimitive,
+		PolygonPrimitive,
+		BezierPrimitive,
+		ColorPrimitive,
+		MattePrimitive,
+		TextPrimitive,
+		ImagePrimitive,
+		PathPrimitive
+	}
+
+	enum ReferenceType
+	{
+		UndefinedReference,
+		GradientReference
+	}
+
+	enum SpreadMethod
+	{
+		UndefinedSpread,
+		PadSpread,
+		ReflectSpread,
+		RepeatSpread
+	}
+
+	struct PointInfo
+	{
+		double
+			x,
+			y;
+	}
+
+	struct StopInfo
+	{
+		MagickPixelPacket
+			color;
+
+		MagickRealType
+			offset;
+	}
+
+	struct GradientInfo
+	{
+		GradientType
+			type;
+
+		RectangleInfo
+			bounding_box;
+
+		SegmentInfo
+			gradient_vector;
+
+		StopInfo*
+			stops;
+
+		size_t
+			number_stops;
+
+		SpreadMethod
+			spread;
+
+		MagickBooleanType
+			ddebug;
+
+		size_t
+			signature;
+
+		PointInfo
+			center;
+
+		MagickRealType
+			radius;
+	}
+
+	struct ElementReference
+	{
+		char*
+			id;
+
+		ReferenceType
+			type;
+
+		GradientInfo
+			gradient;
+
+		size_t
+			signature;
+
+		ElementReference*
+			previous,
+			next;
+	}
+
+	struct DrawInfo
+	{
+		char*
+			primitive,
+			geometry;
+
+		RectangleInfo
+			viewbox;
+
+		AffineMatrix
+			affine;
+
+		GravityType
+			gravity;
+
+		PixelPacket
+			fill,
+			stroke;
+
+		double
+			stroke_width;
+
+		GradientInfo
+			gradient;
+
+		Image*
+			fill_pattern,
+			tile,
+			stroke_pattern;
+
+		MagickBooleanType
+			stroke_antialias,
+			text_antialias;
+
+		FillRule
+			fill_rule;
+
+		LineCap
+			linecap;
+
+		LineJoin
+			linejoin;
+
+		size_t
+			miterlimit;
+
+		double
+			dash_offset;
+
+		DecorationType
+			decorate;
+
+		CompositeOperator
+			compose;
+
+		char*
+			text;
+
+		size_t
+			face;
+
+		char*
+			font,
+			metrics,
+			family;
+
+		StyleType
+			style;
+
+		StretchType
+			stretch;
+
+		size_t
+			weight;
+
+		char*
+			encoding;
+
+		double
+			pointsize;
+
+		char*
+			density;
+
+		AlignType
+			aalign;
+
+		PixelPacket
+			undercolor,
+			border_color;
+
+		char*
+			server_name;
+
+		double*
+			dash_pattern;
+
+		char*
+			clip_mask;
+
+		SegmentInfo
+			bounds;
+
+		ClipPathUnits
+			clip_units;
+
+		Quantum
+			opacity;
+
+		MagickBooleanType
+			render;
+
+		ElementReference
+			element_reference;
+
+		MagickBooleanType
+			ddebug;
+
+		size_t
+			signature;
+
+		double
+			kerning,
+			interword_spacing,
+			interline_spacing;
+
+		DirectionType
+			direction;
+	}
+
+	struct PrimitiveInfo
+	{
+		PointInfo
+			point;
+
+		size_t
+			coordinates;
+
+		PrimitiveType
+			primitive;
+
+		PaintMethod
+			method;
+
+		char*
+			text;
+	}
+
+	struct TypeMetric
+	{
+		PointInfo
+			pixels_per_em;
+
+		double
+			ascent,
+			descent,
+			width,
+			height,
+			max_advance,
+			underline_position,
+			underline_thickness;
+
+		SegmentInfo
+			bounds;
+
+		PointInfo
+			origin;
+	}
+
+	DrawInfo* AcquireDrawInfo();
+	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*);
+
+	void GetAffineMatrix(AffineMatrix*);
+	void GetDrawInfo(const ImageInfo*, DrawInfo*);
+}
diff --git a/dmagick/c/effect.d b/dmagick/c/effect.d
new file mode 100644
index 0000000..b229a8f
--- /dev/null
+++ b/dmagick/c/effect.d
@@ -0,0 +1,74 @@
+module dmagick.c.effect;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.morphology;
+
+extern(C)
+{
+	enum PreviewType
+	{
+		UndefinedPreview,
+		RotatePreview,
+		ShearPreview,
+		RollPreview,
+		HuePreview,
+		SaturationPreview,
+		BrightnessPreview,
+		GammaPreview,
+		SpiffPreview,
+		DullPreview,
+		GrayscalePreview,
+		QuantizePreview,
+		DespecklePreview,
+		ReduceNoisePreview,
+		AddNoisePreview,
+		SharpenPreview,
+		BlurPreview,
+		ThresholdPreview,
+		EdgeDetectPreview,
+		SpreadPreview,
+		SolarizePreview,
+		ShadePreview,
+		RaisePreview,
+		SegmentPreview,
+		SwirlPreview,
+		ImplodePreview,
+		WavePreview,
+		OilPaintPreview,
+		CharcoalDrawingPreview,
+		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*);
+}
diff --git a/dmagick/c/enhance.d b/dmagick/c/enhance.d
new file mode 100644
index 0000000..6138e2c
--- /dev/null
+++ b/dmagick/c/enhance.d
@@ -0,0 +1,44 @@
+module dmagick.c.enhance;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+
+extern(C)
+{
+	MagickBooleanType AutoGammaImage(Image*);
+	MagickBooleanType AutoGammaImageChannel(Image*, const ChannelType);
+	MagickBooleanType AutoLevelImage(Image*);
+	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 ContrastImage(Image*, const MagickBooleanType);
+	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 GammaImageChannel(Image*, const ChannelType, const double);
+	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 LinearStretchImage(Image*, const double, const double);
+	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 SigmoidalContrastImageChannel(Image*, const ChannelType, const MagickBooleanType, const double, const double);
+
+	Image* EnhanceImage(const Image*, ExceptionInfo*);
+}
diff --git a/dmagick/c/exception.d b/dmagick/c/exception.d
new file mode 100644
index 0000000..9236455
--- /dev/null
+++ b/dmagick/c/exception.d
@@ -0,0 +1,137 @@
+module dmagick.c.exception;
+
+import core.vararg;
+
+import dmagick.c.magickType;
+import dmagick.c.semaphore;
+
+extern(C)
+{
+	enum ExceptionType
+	{
+		UndefinedException,
+		WarningException = 300,
+		ResourceLimitWarning = 300,
+		TypeWarning = 305,
+		OptionWarning = 310,
+		DelegateWarning = 315,
+		MissingDelegateWarning = 320,
+		CorruptImageWarning = 325,
+		FileOpenWarning = 330,
+		BlobWarning = 335,
+		StreamWarning = 340,
+		CacheWarning = 345,
+		CoderWarning = 350,
+		FilterWarning = 352,
+		ModuleWarning = 355,
+		DrawWarning = 360,
+		ImageWarning = 365,
+		WandWarning = 370,
+		RandomWarning = 375,
+		XServerWarning = 380,
+		MonitorWarning = 385,
+		RegistryWarning = 390,
+		ConfigureWarning = 395,
+		PolicyWarning = 399,
+		ErrorException = 400,
+		ResourceLimitError = 400,
+		TypeError = 405,
+		OptionError = 410,
+		DelegateError = 415,
+		MissingDelegateError = 420,
+		CorruptImageError = 425,
+		FileOpenError = 430,
+		BlobError = 435,
+		StreamError = 440,
+		CacheError = 445,
+		CoderError = 450,
+		FilterError = 452,
+		ModuleError = 455,
+		DrawError = 460,
+		ImageError = 465,
+		WandError = 470,
+		RandomError = 475,
+		XServerError = 480,
+		MonitorError = 485,
+		RegistryError = 490,
+		ConfigureError = 495,
+		PolicyError = 499,
+		FatalErrorException = 700,
+		ResourceLimitFatalError = 700,
+		TypeFatalError = 705,
+		OptionFatalError = 710,
+		DelegateFatalError = 715,
+		MissingDelegateFatalError = 720,
+		CorruptImageFatalError = 725,
+		FileOpenFatalError = 730,
+		BlobFatalError = 735,
+		StreamFatalError = 740,
+		CacheFatalError = 745,
+		CoderFatalError = 750,
+		FilterFatalError = 752,
+		ModuleFatalError = 755,
+		DrawFatalError = 760,
+		ImageFatalError = 765,
+		WandFatalError = 770,
+		RandomFatalError = 775,
+		XServerFatalError = 780,
+		MonitorFatalError = 785,
+		RegistryFatalError = 790,
+		ConfigureFatalError = 795,
+		PolicyFatalError = 799
+	}
+
+	struct ExceptionInfo
+	{
+		ExceptionType
+			severity;
+
+		int
+			error_number;
+
+		char*
+			reason,
+			description;
+
+		void*
+			exceptions;
+
+		MagickBooleanType
+			relinquish;
+
+		SemaphoreInfo*
+			semaphore;
+
+		size_t
+			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;
+
+	char* GetExceptionMessage(const int);
+
+	const(char*) GetLocaleExceptionMessage(const ExceptionType, const char*);
+
+	ErrorHandler SetErrorHandler(ErrorHandler);
+
+	ExceptionInfo* AcquireExceptionInfo();
+	ExceptionInfo* DestroyExceptionInfo(ExceptionInfo*);
+
+	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);
+
+	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*);
+
+	WarningHandler SetWarningHandler(WarningHandler);
+}
diff --git a/dmagick/c/feature.d b/dmagick/c/feature.d
new file mode 100644
index 0000000..1ebef79
--- /dev/null
+++ b/dmagick/c/feature.d
@@ -0,0 +1,28 @@
+module dmagick.c.feature;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+
+extern(C)
+{
+	struct ChannelFeatures
+	{
+		double[4]
+			angular_second_moment,
+			contrast,
+			correlation,
+			variance_sum_of_squares,
+			inverse_difference_moment,
+			sum_average,
+			sum_variance,
+			sum_entropy,
+			entropy,
+			difference_variance,
+			difference_entropy,
+			measure_of_correlation_1,
+			measure_of_correlation_2,
+			maximum_correlation_coefficient;
+	}
+
+	ChannelFeatures* GetImageChannelFeatures(const Image*, const size_t, ExceptionInfo*);
+}
diff --git a/dmagick/c/fourier.d b/dmagick/c/fourier.d
new file mode 100644
index 0000000..d866dac
--- /dev/null
+++ b/dmagick/c/fourier.d
@@ -0,0 +1,11 @@
+module dmagick.c.fourier;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	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
new file mode 100644
index 0000000..b02a49c
--- /dev/null
+++ b/dmagick/c/fx.d
@@ -0,0 +1,50 @@
+module dmagick.c.fx;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.draw;
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.morphology;
+import dmagick.c.pixel;
+
+extern(C)
+{
+	enum NoiseType
+	{
+		UndefinedNoise,
+		UniformNoise,
+		GaussianNoise,
+		MultiplicativeGaussianNoise,
+		ImpulseNoise,
+		LaplacianNoise,
+		PoissonNoise,
+		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*);
+
+	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
new file mode 100644
index 0000000..1833005
--- /dev/null
+++ b/dmagick/c/gem.d
@@ -0,0 +1,23 @@
+module dmagick.c.gem;
+
+import dmagick.c.geometry;
+import dmagick.c.magickType;
+import dmagick.c.fx;
+import dmagick.c.random;
+
+extern(C)
+{
+	double ExpandAffine(const AffineMatrix*);
+	double GenerateDifferentialNoise(RandomInfo*, const Quantum, const NoiseType, const MagickRealType);
+
+	size_t GetOptimalKernelWidth(const double, const double);
+	size_t GetOptimalKernelWidth1D(const double, const double);
+	size_t GetOptimalKernelWidth2D(const double, const double);
+
+	void ConvertHSBToRGB(const double, const double, const double, Quantum*, Quantum*, Quantum*);
+	void ConvertHSLToRGB(const double, const double, const double, Quantum*, Quantum*, Quantum*);
+	void ConvertHWBToRGB(const double, const double, const double, Quantum*, Quantum *,Quantum*);
+	void ConvertRGBToHSB(const Quantum, const Quantum, const Quantum, double*, double*, double*);
+	void ConvertRGBToHSL(const Quantum, const Quantum, const Quantum, double*, double*, double*);
+	void ConvertRGBToHWB(const Quantum, const Quantum, const Quantum, double*, double*, double*);
+}
diff --git a/dmagick/c/geometry.d b/dmagick/c/geometry.d
new file mode 100644
index 0000000..126944e
--- /dev/null
+++ b/dmagick/c/geometry.d
@@ -0,0 +1,119 @@
+module dmagick.c.geometry;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum GeometryFlags
+	{
+		NoValue = 0x0000,
+
+		XValue  = 0x0001,
+		XiValue = 0x0001,
+
+		YValue   = 0x0002,
+		PsiValue = 0x0002,
+
+		WidthValue = 0x0004,
+		RhoValue   = 0x0004,
+
+		HeightValue = 0x0008,
+		SigmaValue  = 0x0008,
+		ChiValue    = 0x0010,
+		XiNegative  = 0x0020,
+
+		XNegative   = 0x0020,
+		PsiNegative = 0x0040,
+
+		YNegative      = 0x0040,
+		ChiNegative    = 0x0080,
+		PercentValue   = 0x1000,
+		AspectValue    = 0x2000,
+		NormalizeValue = 0x2000,
+		LessValue      = 0x4000,
+		GreaterValue   = 0x8000,
+		MinimumValue   = 0x10000,
+		CorrelateNormalizeValue = 0x10000,
+		AreaValue      = 0x20000,
+		DecimalValue   = 0x40000,
+
+		AllValues = 0x7fffffff
+	}
+
+	enum GravityType
+	{
+		UndefinedGravity,
+		ForgetGravity    = 0,
+		NorthWestGravity = 1,
+		NorthGravity     = 2,
+		NorthEastGravity = 3,
+		WestGravity      = 4,
+		CenterGravity    = 5,
+		EastGravity      = 6,
+		SouthWestGravity = 7,
+		SouthGravity     = 8,
+		SouthEastGravity = 9,
+		StaticGravity    = 10
+	}
+
+	struct AffineMatrix
+	{
+		double
+			sx,
+			rx,
+			ry,
+			sy,
+			tx,
+			ty;
+	}
+
+	struct GeometryInfo
+	{
+		double
+			rho,
+			sigma,
+			xi,
+			psi,
+			chi;
+	}
+
+	struct OffsetInfo
+	{
+		ssize_t
+			x,
+			y;
+	}
+
+	struct RectangleInfo
+	{
+		size_t
+			width,
+			height;
+
+		ssize_t
+			x,
+			y;
+	}
+
+	char* GetPageGeometry(const char*);
+
+	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*);
+
+	void GravityAdjustGeometry(const size_t, const size_t, const GravityType, RectangleInfo*);
+	void SetGeometry(const Image*, RectangleInfo*);
+	void SetGeometryInfo(GeometryInfo*);
+}
diff --git a/dmagick/c/hashmap.d b/dmagick/c/hashmap.d
new file mode 100644
index 0000000..a0bcfb2
--- /dev/null
+++ b/dmagick/c/hashmap.d
@@ -0,0 +1,47 @@
+module dmagick.c.hashmap;
+
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct HashmapInfo {}
+
+	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*));
+
+	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 LinkedListToArray(LinkedListInfo*, 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*);
+
+	void  ClearLinkedList(LinkedListInfo*, void* function(void*));
+	void* GetLastValueInLinkedList(LinkedListInfo*);
+	void* GetNextKeyInHashmap(HashmapInfo*);
+	void* GetNextValueInHashmap(HashmapInfo*);
+	void* GetNextValueInLinkedList(LinkedListInfo*);
+	void* GetValueFromHashmap(HashmapInfo*, const void*);
+	void* GetValueFromLinkedList(LinkedListInfo*, const size_t);
+	void* RemoveElementByValueFromLinkedList(LinkedListInfo*, const void*);
+	void* RemoveElementFromLinkedList(LinkedListInfo*, const size_t);
+	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
new file mode 100644
index 0000000..2341186
--- /dev/null
+++ b/dmagick/c/histogram.d
@@ -0,0 +1,33 @@
+module dmagick.c.histogram;
+
+import core.stdc.stdio;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+
+extern(C)
+{
+	struct ColorPacket
+	{
+		PixelPacket
+			pixel;
+
+		IndexPacket
+			index;
+
+		MagickSizeType
+			count;
+	}
+
+	ColorPacket* GetImageHistogram(const Image*, size_t*, ExceptionInfo*);
+
+	Image* UniqueImageColors(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*);
+}
diff --git a/dmagick/c/identify.d b/dmagick/c/identify.d
new file mode 100644
index 0000000..a1b523c
--- /dev/null
+++ b/dmagick/c/identify.d
@@ -0,0 +1,8 @@
+module dmagick.c.identify;
+
+import core.stdc.stdio;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C) MagickBooleanType IdentifyImage(Image*, FILE*, const MagickBooleanType);
diff --git a/dmagick/c/image.d b/dmagick/c/image.d
new file mode 100644
index 0000000..54adb1e
--- /dev/null
+++ b/dmagick/c/image.d
@@ -0,0 +1,536 @@
+module dmagick.c.image;
+
+import core.stdc.stdio;
+import core.sys.posix.sys.types;
+
+import dmagick.c.cacheView;
+import dmagick.c.color;
+import dmagick.c.colorspace;
+import dmagick.c.composite;
+import dmagick.c.compress;
+import dmagick.c.compress;
+import dmagick.c.effect;
+import dmagick.c.exception;
+import dmagick.c.geometry;
+import dmagick.c.layer;
+import dmagick.c.magickType;
+import dmagick.c.monitor;
+import dmagick.c.pixel;
+import dmagick.c.profile;
+import dmagick.c.quantum;
+import dmagick.c.resample;
+import dmagick.c.semaphore;
+import dmagick.c.stream;
+import dmagick.c.timer;
+
+extern(C)
+{
+	enum AlphaChannelType
+	{
+		UndefinedAlphaChannel,
+		ActivateAlphaChannel,
+		BackgroundAlphaChannel,
+		CopyAlphaChannel,
+		DeactivateAlphaChannel,
+		ExtractAlphaChannel,
+		OpaqueAlphaChannel,
+		ResetAlphaChannel,
+		SetAlphaChannel,
+		ShapeAlphaChannel,
+		TransparentAlphaChannel
+	}
+
+	enum ImageType
+	{
+		UndefinedType,
+		BilevelType,
+		GrayscaleType,
+		GrayscaleMatteType,
+		PaletteType,
+		PaletteMatteType,
+		TrueColorType,
+		TrueColorMatteType,
+		ColorSeparationType,
+		ColorSeparationMatteType,
+		OptimizeType,
+		PaletteBilevelMatteType
+	}
+
+	enum InterlaceType
+	{
+		UndefinedInterlace,
+		NoInterlace,
+		LineInterlace,
+		PlaneInterlace,
+		PartitionInterlace,
+		GIFInterlace,
+		JPEGInterlace,
+		PNGInterlace
+	}
+
+	enum OrientationType
+	{
+		UndefinedOrientation,
+		TopLeftOrientation,
+		TopRightOrientation,
+		BottomRightOrientation,
+		BottomLeftOrientation,
+		LeftTopOrientation,
+		RightTopOrientation,
+		RightBottomOrientation,
+		LeftBottomOrientation
+	}
+
+	enum ResolutionType
+	{
+		UndefinedResolution,
+		PixelsPerInchResolution,
+		PixelsPerCentimeterResolution
+	}
+
+	struct PrimaryInfo
+	{
+		double
+			x,
+			y,
+			z;
+	}
+
+	struct SegmentInfo
+	{
+		double
+			x1,
+			y1,
+			x2,
+			y2;
+	}
+
+	enum TransmitType
+	{
+		UndefinedTransmitType,
+		FileTransmitType,
+		BlobTransmitType,
+		StreamTransmitType,
+		ImageTransmitType
+	}
+
+	struct ChromaticityInfo
+	{
+		PrimaryInfo
+			red_primary,
+			green_primary,
+			blue_primary,
+			white_point;
+	}
+
+	struct Image
+	{
+		ClassType
+			storage_class;
+
+		ColorspaceType
+			colorspace;
+
+		CompressionType
+			compression;
+
+		size_t
+			quality;
+
+		OrientationType
+			orientation;
+
+		//MagickBooleanType
+		int
+			taint,
+			matte;
+
+		size_t
+			columns,
+			rows,
+			depth,
+			colors;
+
+		PixelPacket*
+			colormap;
+
+		PixelPacket
+			background_color,
+			border_color,
+			matte_color;
+
+		double
+			gamma;
+
+		ChromaticityInfo
+			chromaticity;
+
+		RenderingIntent
+			rendering_intent;
+
+		void*
+			profiles;
+
+		ResolutionType
+			units;
+
+		char*
+			montage,
+			directory,
+			geometry;
+
+		ssize_t
+			offset;
+
+		double
+			x_resolution,
+			y_resolution;
+
+		RectangleInfo
+			page,
+			extract_info,
+			tile_info;
+
+		double
+			bias,
+			blur,
+			fuzz;
+
+		FilterTypes
+			filter;
+
+		InterlaceType
+			interlace;
+
+		EndianType
+			endian;
+
+		GravityType
+			gravity;
+
+		CompositeOperator
+			compose;
+
+		DisposeType
+			dispose;
+
+		Image*
+			clip_mask;
+
+		size_t
+			scene,
+			delay;
+
+		ssize_t
+			ticks_per_second;
+
+		size_t
+			iterations,
+			total_colors;
+
+		ssize_t
+			start_loop;
+
+		ErrorInfo
+			error;
+
+		TimerInfo
+			timer;
+
+		MagickProgressMonitor
+			progress_monitor;
+
+		void*
+			client_data,
+			cache,
+			attributes;
+
+		Ascii85Info*
+			ascii85;
+
+		BlobInfo*
+			blob;
+
+		char[MaxTextExtent]
+			filename,
+			magick_filename,
+			magick;
+
+		size_t
+			magick_columns,
+			magick_rows;
+
+		ExceptionInfo
+			exception;
+
+		//MagickBooleanType
+		int
+			ddebug;
+
+		ssize_t
+			reference_count;
+
+		SemaphoreInfo*
+			semaphore;
+
+		ProfileInfo
+			color_profile,
+			iptc_profile;
+
+		ProfileInfo*
+			generic_profile;
+
+		size_t
+			generic_profiles;
+
+		size_t
+			signature;
+
+		Image*
+			previous,
+			list,
+			next;
+
+		InterpolatePixelMethod
+			interpolate;
+
+		//MagickBooleanType
+		int
+			black_point_compensation;
+
+		PixelPacket
+			transparent_color;
+
+		Image*
+			mask;
+
+		RectangleInfo
+			tile_offset;
+
+		void*
+			properties,
+			artifacts;
+
+		ImageType
+			type;
+
+		//MagickBooleanType
+		int
+			dither;
+
+		MagickSizeType
+			extent;
+
+		//MagickBooleanType
+		int
+			ping;
+	}
+
+	struct ImageInfo
+	{
+		CompressionType
+			compression;
+
+		OrientationType
+			orientation;
+
+		//MagickBooleanType
+		int
+			temporary,
+			adjoin,
+			affirm,
+			antialias;
+
+		char*
+			size,
+			extract,
+			page,
+			scenes;
+
+		size_t
+			scene,
+			number_scenes,
+			depth;
+
+		InterlaceType
+			interlace;
+
+		EndianType
+			endian;
+
+		ResolutionType
+			units;
+
+		size_t
+			quality;
+
+		char*
+			sampling_factor,
+			server_name,
+			font,
+			texture,
+			density;
+
+		double
+			pointsize,
+			fuzz;
+
+		PixelPacket
+			background_color,
+			border_color,
+			matte_color;
+
+		//MagickBooleanType
+		int
+			dither,
+			monochrome;
+
+		size_t
+			colors;
+
+		ColorspaceType
+			colorspace;
+
+		ImageType
+			type;
+
+		PreviewType
+			preview_type;
+
+		ssize_t
+			group;
+
+		//MagickBooleanType
+		int
+			ping,
+			verbose;
+
+		char*
+			view,
+			authenticate;
+
+		ChannelType
+			channel;
+
+		Image*
+			attributes;
+
+		void*
+			options;
+
+		MagickProgressMonitor
+			progress_monitor;
+
+		void*
+			client_data,
+			cache;
+
+		StreamHandler
+			stream;
+
+		FILE*
+			file;
+
+		void*
+			blob;
+
+		size_t
+			length;
+
+		char[MaxTextExtent]
+			magick,
+			unique,
+			zero,
+			filename;
+
+		//MagickBooleanType
+		int
+			ddebug;
+
+		char*
+			tile;
+
+		size_t
+			subimage,
+			subrange;
+
+		PixelPacket
+			pen;
+
+		size_t
+			signature;
+
+		VirtualPixelMethod
+			virtual_pixel_method;
+
+		PixelPacket
+			transparent_color;
+
+		void*
+			profile;
+
+		//MagickBooleanType
+		int
+			synchronize;
+	}
+
+	ExceptionType CatchImageException(Image*);
+
+	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* 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* ReferenceImage(Image*);
+	Image* SeparateImages(const Image*, const ChannelType, ExceptionInfo*);
+
+	ImageInfo* AcquireImageInfo();
+	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 ListMagickInfo(FILE*, ExceptionInfo*);
+	MagickBooleanType ModifyImage(Image**, ExceptionInfo*);
+	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 SetImageExtent(Image*, const size_t, const size_t);
+	MagickBooleanType SetImageInfo(ImageInfo*, const uint, ExceptionInfo*);
+	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 SyncImagesSettings(ImageInfo*, Image*);
+
+	size_t InterpretImageFilename(const ImageInfo*, Image*, const char*, int, char*);
+
+	ssize_t GetImageReferenceCount(Image*);
+
+	VirtualPixelMethod GetImageVirtualPixelMethod(const Image*);
+	VirtualPixelMethod SetImageVirtualPixelMethod(const Image*, const VirtualPixelMethod);
+
+	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 SetImageInfoFile(ImageInfo*, FILE*);
+}
diff --git a/dmagick/c/imageView.d b/dmagick/c/imageView.d
new file mode 100644
index 0000000..cd3ddb5
--- /dev/null
+++ b/dmagick/c/imageView.d
@@ -0,0 +1,48 @@
+module dmagick.c.imageView;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.geometry;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+
+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(ImageView*, const ssize_t, const int, void*) SetImageViewMethod;
+	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*);
+
+	const(IndexPacket*) GetImageViewVirtualIndexes(const ImageView*);
+
+	const(PixelPacket*) GetImageViewVirtualPixels(const ImageView*);
+
+	Image* GetImageViewImage(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*);
+
+	MagickBooleanType DuplexTransferImageViewIterator(ImageView*, ImageView*, ImageView*, DuplexTransferImageViewMethod, void*);
+	MagickBooleanType GetImageViewIterator(ImageView*, GetImageViewMethod, void*);
+	MagickBooleanType IsImageView(const ImageView*);
+	MagickBooleanType SetImageViewIterator(ImageView*, SetImageViewMethod, void*);
+	MagickBooleanType TransferImageViewIterator(ImageView*, ImageView*, TransferImageViewMethod, void*);
+	MagickBooleanType UpdateImageViewIterator(ImageView*, UpdateImageViewMethod, void*);
+
+	PixelPacket* GetImageViewAuthenticPixels(const ImageView*);
+
+	RectangleInfo GetImageViewExtent(const ImageView*);
+
+	void SetImageViewDescription(ImageView*, const char*);
+}
diff --git a/dmagick/c/layer.d b/dmagick/c/layer.d
new file mode 100644
index 0000000..b71490e
--- /dev/null
+++ b/dmagick/c/layer.d
@@ -0,0 +1,53 @@
+module dmagick.c.layer;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.composite;
+import dmagick.c.exception;
+import dmagick.c.image;
+
+extern(C)
+{
+	enum DisposeType
+	{
+		UnrecognizedDispose,
+		UndefinedDispose = 0,
+		NoneDispose = 1,
+		BackgroundDispose = 2,
+		PreviousDispose = 3
+	}
+
+	enum ImageLayerMethod
+	{
+		UndefinedLayer,
+		CoalesceLayer,
+		CompareAnyLayer,
+		CompareClearLayer,
+		CompareOverlayLayer,
+		DisposeLayer,
+		OptimizeLayer,
+		OptimizeImageLayer,
+		OptimizePlusLayer,
+		OptimizeTransLayer,
+		RemoveDupsLayer,
+		RemoveZeroLayer,
+		CompositeLayer,
+		MergeLayer,
+		FlattenLayer,
+		MosaicLayer,
+		TrimBoundsLayer
+	}
+
+	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*);
+
+	void CompositeLayers(Image*, const CompositeOperator, Image*, const ssize_t, const ssize_t, 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
new file mode 100644
index 0000000..9b91807
--- /dev/null
+++ b/dmagick/c/list.d
@@ -0,0 +1,39 @@
+module dmagick.c.list;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+
+extern(C)
+{
+	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*  NewImageList();
+	Image*  RemoveImageFromList(Image**);
+	Image*  RemoveLastImageFromList(Image**);
+	Image*  RemoveFirstImageFromList(Image**);
+	Image*  SpliceImageIntoList(Image**, const size_t, const Image*);
+	Image*  SplitImageList(Image*);
+	Image*  SyncNextImageInList(const Image*);
+
+	size_t GetImageListLength(const Image*);
+
+	ssize_t GetImageIndexInList(const Image*);
+
+	void AppendImageToList(Image**, const Image*);
+	void DeleteImageFromList(Image**);
+	void DeleteImages(Image**, const char*, ExceptionInfo*);
+	void InsertImageInList(Image**, Image*);
+	void PrependImageToList(Image**, Image*);
+	void ReplaceImageInList(Image**, Image*);
+	void ReverseImageList(Image**);
+	void SyncImageList(Image*);
+}
diff --git a/dmagick/c/locale.d b/dmagick/c/locale.d
new file mode 100644
index 0000000..73f1a11
--- /dev/null
+++ b/dmagick/c/locale.d
@@ -0,0 +1,43 @@
+module dmagick.c.locale;
+
+import core.stdc.stdio;
+
+import dmagick.c.exception;
+import dmagick.c.hashmap;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct LocaleInfo
+	{
+		char*
+			path,
+			tag,
+			message;
+
+		MagickBooleanType
+			stealth;
+
+		LocaleInfo*
+			previous,
+			next;
+
+		size_t
+			signature;
+	}
+
+	char** GetLocaleList(const char*, size_t*, ExceptionInfo*);
+
+	const(char*) GetLocaleMessage(const char*);
+
+	const(LocaleInfo*)  GetLocaleInfo_(const char*, ExceptionInfo*);
+	const(LocaleInfo**) GetLocaleInfoList(const char*, size_t*, ExceptionInfo*);
+
+	LinkedListInfo* DestroyLocaleOptions(LinkedListInfo*);
+	LinkedListInfo* GetLocaleOptions(const char*, ExceptionInfo*);
+
+	MagickBooleanType ListLocaleInfo(FILE*, ExceptionInfo*);
+	MagickBooleanType LocaleComponentGenesis();
+
+	void LocaleComponentTerminus();
+}
diff --git a/dmagick/c/log.d b/dmagick/c/log.d
new file mode 100644
index 0000000..d7db729
--- /dev/null
+++ b/dmagick/c/log.d
@@ -0,0 +1,56 @@
+module dmagick.c.log;
+
+import core.stdc.stdio;
+import core.vararg;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum LogEventType
+	{
+		UndefinedEvents,
+		NoEvents = 0x00000,
+		TraceEvent = 0x00001,
+		AnnotateEvent = 0x00002,
+		BlobEvent = 0x00004,
+		CacheEvent = 0x00008,
+		CoderEvent = 0x00010,
+		ConfigureEvent = 0x00020,
+		DeprecateEvent = 0x00040,
+		DrawEvent = 0x00080,
+		ExceptionEvent = 0x00100,
+		ImageEvent = 0x00200,
+		LocaleEvent = 0x00400,
+		ModuleEvent = 0x00800,
+		PolicyEvent = 0x01000,
+		ResourceEvent = 0x02000,
+		TransformEvent = 0x04000,
+		UserEvent = 0x09000,
+		WandEvent = 0x10000,
+		X11Event = 0x20000,
+		AllEvents = 0x7fffffff
+	}
+
+	struct LogInfo {}
+
+	char** GetLogList(const char*, size_t*, ExceptionInfo*);
+
+	const(char*) GetLogName();
+	const(char*) SetLogName(const char*);
+
+	const(LogInfo**) GetLogInfoList(const char*, size_t*, ExceptionInfo*);
+
+	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);
+
+	void CloseMagickLog();
+	void LogComponentTerminus();
+	void SetLogFormat(const char*);
+}
diff --git a/dmagick/c/magic.d b/dmagick/c/magic.d
new file mode 100644
index 0000000..1157633
--- /dev/null
+++ b/dmagick/c/magic.d
@@ -0,0 +1,50 @@
+module dmagick.c.magic;
+
+import core.stdc.stdio;
+import core.vararg;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct MagicInfo
+	{
+		char*
+			path,
+			name,
+			target;
+
+		ubyte*
+			magic;
+
+		size_t
+			length;
+
+		MagickOffsetType
+			offset;
+
+		MagickBooleanType
+			exempt,
+			stealth;
+
+		MagicInfo*
+			previous,
+			next;
+
+		size_t
+			signature;
+	}
+
+	char** GetMagicList(const char*, size_t*, ExceptionInfo*);
+
+	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*);
+
+	void MagicComponentTerminus();
+}
diff --git a/dmagick/c/magick.d b/dmagick/c/magick.d
new file mode 100644
index 0000000..d343cd2
--- /dev/null
+++ b/dmagick/c/magick.d
@@ -0,0 +1,107 @@
+module dmagick.c.magick;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum MagickFormatType
+	{
+		UndefinedFormatType,
+		ImplicitFormatType,
+		ExplicitFormatType
+	}
+
+	enum MagickThreadSupport
+	{
+		NoThreadSupport = 0x0000,
+		DecoderThreadSupport = 0x0001,
+		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;
+
+	struct MagickInfo
+	{
+		char*
+			name,
+			description,
+			vversion,
+			note,
+			mmodule;
+
+		ImageInfo*
+			image_info;
+
+		DecodeImageHandler*
+			decoder;
+
+		EncodeImageHandler*
+			encoder;
+
+		IsImageFormatHandler*
+			magick;
+
+		void*
+			client_data;
+
+		MagickBooleanType
+			adjoin,
+			raw,
+			endian_support,
+			blob_support,
+			seekable_stream;
+
+		MagickFormatType
+			format_type;
+
+		MagickStatusType
+			thread_support;
+
+		MagickBooleanType
+			stealth;
+
+		MagickInfo*
+			previous,
+			next;
+
+		size_t
+			signature;
+	}
+
+	char** GetMagickList(const char*, size_t*, ExceptionInfo*);
+
+	const(char*) GetMagickDescription(const MagickInfo*);
+
+	DecodeImageHandler* GetImageDecoder(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 IsMagickInstantiated();
+	MagickBooleanType MagickComponentGenesis();
+	MagickBooleanType UnregisterMagickInfo(const char*);
+
+	const(MagickInfo*)  GetMagickInfo(const char*, ExceptionInfo*);
+	const(MagickInfo**) GetMagickInfoList(const char*, size_t*, ExceptionInfo*);
+
+	MagickInfo* RegisterMagickInfo(MagickInfo*);
+	MagickInfo* SetMagickInfo(const char*);
+
+	MagickStatusType GetMagickThreadSupport(const MagickInfo*);
+
+	void MagickComponentTerminus();
+	void MagickCoreGenesis(const char*, const MagickBooleanType);
+	void MagickCoreTerminus();
+}
diff --git a/dmagick/c/magickDelegate.d b/dmagick/c/magickDelegate.d
new file mode 100644
index 0000000..e458c33
--- /dev/null
+++ b/dmagick/c/magickDelegate.d
@@ -0,0 +1,52 @@
+module dmagick.c.magickDelegate;
+
+import core.stdc.stdio;
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct DelegateInfo
+	{
+		char*
+			path,
+			decode,
+			encode,
+			commands;
+
+		ssize_t
+			mode;
+
+		MagickBooleanType
+			thread_support,
+			spawn,
+			stealth;
+
+		DelegateInfo*
+			previous,
+			next;
+
+		size_t
+			signature;
+	}
+
+	char*  GetDelegateCommand(const ImageInfo*, Image*, const char*, const char*, ExceptionInfo*);
+	char** GetDelegateList(const char *,size_t *,ExceptionInfo *);
+
+	const(char*) GetDelegateCommands(const DelegateInfo*);
+
+	const(DelegateInfo*)  GetDelegateInfo(const char*, const char*, ExceptionInfo* exception);
+	const(DelegateInfo**) GetDelegateInfoList(const char*, size_t*, ExceptionInfo*);
+
+	ssize_t GetDelegateMode(const DelegateInfo*);
+
+	MagickBooleanType DelegateComponentGenesis();
+	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
new file mode 100644
index 0000000..6776fde
--- /dev/null
+++ b/dmagick/c/magickModule.d
@@ -0,0 +1,66 @@
+module dmagick.c.magickModule;
+
+import core.stdc.stdio;
+import core.stdc.time;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum MagickModuleType
+	{
+		MagickImageCoderModule,
+		MagickImageFilterModule
+	}
+
+	struct ModuleInfo
+	{
+		char*
+			path,
+			tag;
+
+		void*
+			handle;
+
+		void
+			function() unregister_module;
+
+		size_t
+			function() register_module;
+
+		time_t
+			timestamp;
+
+		MagickBooleanType
+			stealth;
+
+		ModuleInfo*
+			previous,
+			next;
+
+		size_t
+			signature;
+	}
+
+	size_t ImageFilterHandler(Image**, const int, const char**, ExceptionInfo*);
+
+	char** GetModuleList(const char*, const MagickModuleType, 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 ListModuleInfo(FILE*, ExceptionInfo*);
+	MagickBooleanType ModuleComponentGenesis();
+	MagickBooleanType OpenModule(const char*, ExceptionInfo*);
+	MagickBooleanType OpenModules(ExceptionInfo*);
+
+	ModuleInfo* GetModuleInfo(const char*, ExceptionInfo*);
+
+	void DestroyModuleList();
+	void ModuleComponentTerminus();
+	void RegisterStaticModules();
+	void UnregisterStaticModules();
+}
diff --git a/dmagick/c/magickString.d b/dmagick/c/magickString.d
new file mode 100644
index 0000000..8606069
--- /dev/null
+++ b/dmagick/c/magickString.d
@@ -0,0 +1,78 @@
+module dmagick.c.magickString;
+
+import core.stdc.stdio;
+import core.stdc.time;
+import core.sys.posix.sys.types;
+import core.vararg;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct StringInfo
+	{
+		char[MaxTextExtent]
+			path;
+
+		ubyte*
+			datum;
+
+		size_t
+			length,
+			signature;
+	}
+
+	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*);
+
+	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);
+
+	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*);
+
+	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	FormatMagickTime(const time_t, const size_t, char*);
+
+	StringInfo* AcquireStringInfo(const size_t);
+	StringInfo* CloneStringInfo(const StringInfo*);
+	StringInfo* ConfigureFileToStringInfo(const char*);
+	StringInfo* DestroyStringInfo(StringInfo*);
+	StringInfo* FileToStringInfo(const char*, const size_t, ExceptionInfo*);
+	StringInfo* SplitStringInfo(StringInfo*, const size_t);
+	StringInfo* StringToStringInfo(const char*);
+
+	ubyte* GetStringInfoDatum(const StringInfo*);
+
+	void ConcatenateStringInfo(StringInfo*, const StringInfo*);
+	void LocaleLower(char*);
+	void LocaleUpper(char*);
+	void PrintStringInfo(FILE *file, const char*, const StringInfo*);
+	void ResetStringInfo(StringInfo*);
+	void SetStringInfo(StringInfo*, const StringInfo*);
+	void SetStringInfoDatum(StringInfo*, const ubyte*);
+	void SetStringInfoLength(StringInfo*, const size_t);
+	void SetStringInfoPath(StringInfo*, const char*);
+	void StripString(char*);
+}
diff --git a/dmagick/c/magickType.d b/dmagick/c/magickType.d
new file mode 100644
index 0000000..498fb61
--- /dev/null
+++ b/dmagick/c/magickType.d
@@ -0,0 +1,59 @@
+module dmagick.c.magickType;
+
+extern (C)
+{
+	alias double MagickRealType;
+	alias ushort Quantum;
+	alias uint   MagickStatusType;
+	alias long   MagickOffsetType;
+	alias ulong  MagickSizeType;
+
+	alias MagickSizeType QuantumAny;
+
+	enum MaxTextExtent = 4096;
+	enum QuantumRange = 65535UL;
+
+	enum ChannelType
+	{
+		UndefinedChannel,
+		RedChannel     = 0x0001,
+		GrayChannel    = 0x0001,
+		CyanChannel    = 0x0001,
+		GreenChannel   = 0x0002,
+		MagentaChannel = 0x0002,
+		BlueChannel    = 0x0004,
+		YellowChannel  = 0x0004,
+		AlphaChannel   = 0x0008,
+		OpacityChannel = 0x0008,
+		MatteChannel   = 0x0008,  // deprecated
+		BlackChannel   = 0x0020,
+		IndexChannel   = 0x0020,
+		AllChannels    = 0x002F,
+
+		TrueAlphaChannel = 0x0040, // extract actual alpha channel from opacity
+		RGBChannels      = 0x0080, // set alpha from  grayscale mask in RGB
+		GrayChannels     = 0x0080,
+		SyncChannels     = 0x0100, // channels should be modified equally
+		DefaultChannels  = 0x0127  //( (AllChannels | SyncChannels) &~ OpacityChannel)
+	}
+
+	enum ClassType
+	{
+		UndefinedClass,
+		DirectClass,
+		PseudoClass
+	}
+
+	alias int MagickBooleanType;
+
+	//typedef enum
+	//{
+	//	MagickFalse = 0,
+	//	MagickTrue = 1
+	//} MagickBooleanType;
+
+	struct BlobInfo {}
+
+	//alias _Image Image;
+	//alias _ImageInfo ImageInfo;
+}
diff --git a/dmagick/c/magickVersion.d b/dmagick/c/magickVersion.d
new file mode 100644
index 0000000..eaed81c
--- /dev/null
+++ b/dmagick/c/magickVersion.d
@@ -0,0 +1,14 @@
+module dmagick.c.magickVersion;
+
+extern(C)
+{
+	char* GetMagickHomeURL();
+
+	const(char*) GetMagickCopyright();
+	const(char*) GetMagickFeatures();
+	const(char*) GetMagickPackageName();
+	const(char*) GetMagickQuantumDepth(size_t*);
+	const(char*) GetMagickQuantumRange(size_t*);
+	const(char*) GetMagickReleaseDate();
+	const(char*) GetMagickVersion(size_t*);
+}
diff --git a/dmagick/c/matrix.d b/dmagick/c/matrix.d
new file mode 100644
index 0000000..ecbd998
--- /dev/null
+++ b/dmagick/c/matrix.d
@@ -0,0 +1,13 @@
+module dmagick.c.matrix;
+
+import dmagick.c.magickType;
+
+extern(C)
+{
+	double** AcquireMagickMatrix(const size_t, const size_t);
+	double** RelinquishMagickMatrix(double**, const size_t);
+
+	MagickBooleanType GaussJordanElimination(double**, 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
new file mode 100644
index 0000000..8c10eeb
--- /dev/null
+++ b/dmagick/c/memory.d
@@ -0,0 +1,21 @@
+module dmagick.c.memory;
+
+extern(C)
+{
+	alias void* function(size_t) AcquireMemoryHandler;
+	alias void	function(void*) DestroyMemoryHandler;
+	alias void* function(void*, size_t) ResizeMemoryHandler;
+
+	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  DestroyMagickMemory();
+	void  GetMagickMemoryMethods(AcquireMemoryHandler*, ResizeMemoryHandler*, DestroyMemoryHandler*);
+	void* RelinquishAlignedMemory(void*);
+	void* RelinquishMagickMemory(void*);
+	void* ResetMagickMemory(void*, int, const size_t);
+	void* ResizeMagickMemory(void*, const size_t);
+	void* ResizeQuantumMemory(void*, const size_t, const size_t);
+	void  SetMagickMemoryMethods(AcquireMemoryHandler, ResizeMemoryHandler, DestroyMemoryHandler);
+}
diff --git a/dmagick/c/mime.d b/dmagick/c/mime.d
new file mode 100644
index 0000000..8e2b337
--- /dev/null
+++ b/dmagick/c/mime.d
@@ -0,0 +1,26 @@
+module dmagick.c.mime;
+
+import core.stdc.stdio;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct MimeInfo {}
+
+	char** GetMimeList(const char*, size_t*, ExceptionInfo*);
+	char*  MagickToMime(const char*);
+
+	const(char*) GetMimeDescription(const MimeInfo*);
+	const(char*) GetMimeType(const MimeInfo*);
+
+	MagickBooleanType ListMimeInfo(FILE*, 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*);
+
+	void MimeComponentTerminus();
+}
diff --git a/dmagick/c/monitor.d b/dmagick/c/monitor.d
new file mode 100644
index 0000000..6d0651e
--- /dev/null
+++ b/dmagick/c/monitor.d
@@ -0,0 +1,23 @@
+module dmagick.c.monitor;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	alias MagickBooleanType function(const char*, const MagickOffsetType, const MagickSizeType, void*) MagickProgressMonitor;
+
+	MagickProgressMonitor SetImageProgressMonitor(Image*, const MagickProgressMonitor, void*);
+	MagickProgressMonitor SetImageInfoProgressMonitor(ImageInfo*, const MagickProgressMonitor, void*);
+}
+
+static pure nothrow MagickBooleanType QuantumTick(const MagickOffsetType offset, const MagickSizeType span)
+{
+	if (span <= 100)
+		return(true);
+	if (offset == cast(MagickOffsetType) (span-1))
+		return(true);
+	if ((offset % (span/100)) == 0)
+		return(true);
+	return(false);
+}
diff --git a/dmagick/c/montage.d b/dmagick/c/montage.d
new file mode 100644
index 0000000..0603e79
--- /dev/null
+++ b/dmagick/c/montage.d
@@ -0,0 +1,65 @@
+module dmagick.c.montage;
+
+import dmagick.c.exception;
+import dmagick.c.geometry;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+
+extern(C)
+{
+	enum MontageMode
+	{
+		UndefinedMode,
+		FrameMode,
+		UnframeMode,
+		ConcatenateMode
+	}
+
+	struct MontageInfo
+	{
+		char*
+			geometry,
+			tile,
+			title,
+			frame,
+			texture,
+			font;
+
+		double
+			pointsize;
+
+		size_t
+			border_width;
+
+		MagickBooleanType
+			shadow;
+
+		PixelPacket
+			fill,
+			stroke,
+			background_color,
+			border_color,
+			matte_color;
+
+		GravityType
+			gravity;
+
+		char[MaxTextExtent]
+			filename;
+
+		MagickBooleanType
+			ddebug;
+
+		size_t
+			signature;
+	}
+
+	Image* MontageImages(const Image*, const MontageInfo*, ExceptionInfo*);
+	Image* MontageImageList(const ImageInfo*, const MontageInfo*, const Image*, ExceptionInfo*);
+
+	MontageInfo* CloneMontageInfo(const ImageInfo*, const MontageInfo*);
+	MontageInfo* DestroyMontageInfo(MontageInfo*);
+
+	void GetMontageInfo(const ImageInfo*, MontageInfo*);
+}
diff --git a/dmagick/c/morphology.d b/dmagick/c/morphology.d
new file mode 100644
index 0000000..baae868
--- /dev/null
+++ b/dmagick/c/morphology.d
@@ -0,0 +1,120 @@
+module dmagick.c.morphology;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.geometry;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum KernelInfoType
+	{
+		UndefinedKernel,
+		UnityKernel,
+		GaussianKernel,
+		DoGKernel,
+		LoGKernel,
+		BlurKernel,
+		CometKernel,
+		LaplacianKernel,
+		SobelKernel,
+		FreiChenKernel,
+		RobertsKernel,
+		PrewittKernel,
+		CompassKernel,
+		KirschKernel,
+		DiamondKernel,
+		SquareKernel,
+		RectangleKernel,
+		DiskKernel,
+		PlusKernel,
+		CrossKernel,
+		RingKernel,
+		PeaksKernel,
+		EdgesKernel,
+		CornersKernel,
+		ThinDiagonalsKernel,
+		LineEndsKernel,
+		LineJunctionsKernel,
+		RidgesKernel,
+		ConvexHullKernel,
+		SkeletonKernel,
+		ChebyshevKernel,
+		ManhattanKernel,
+		EuclideanKernel,
+		UserDefinedKernel
+	}
+
+	enum MorphologyMethod
+	{
+		UndefinedMorphology,
+
+		ConvolveMorphology,
+		CorrelateMorphology,
+
+		ErodeMorphology,
+		DilateMorphology,
+		ErodeIntensityMorphology,
+		DilateIntensityMorphology,
+		DistanceMorphology,
+
+		OpenMorphology,
+		CloseMorphology,
+		OpenIntensityMorphology,
+		CloseIntensityMorphology,
+		SmoothMorphology,
+
+		EdgeInMorphology,
+		EdgeOutMorphology,
+		EdgeMorphology,
+		TopHatMorphology,
+		BottomHatMorphology,
+
+		HitAndMissMorphology,
+		ThinningMorphology,
+		ThickenMorphology
+	}
+
+	struct KernelInfo
+	{
+		KernelInfoType
+			type;
+
+		size_t
+			width,
+			height;
+
+		ssize_t
+			x,
+			y;
+
+		double* values;
+
+		double
+			minimum,
+			maximum,
+			negative_range,
+			positive_range,
+			angle;
+
+		KernelInfo*
+			next;
+
+		size_t
+			signature;
+	}
+
+
+	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*);
+
+	void ScaleGeometryKernelInfo(KernelInfo*, const char*);
+	void ShowKernelInfo(KernelInfo*);
+}
diff --git a/dmagick/c/option.d b/dmagick/c/option.d
new file mode 100644
index 0000000..a766a87
--- /dev/null
+++ b/dmagick/c/option.d
@@ -0,0 +1,132 @@
+module dmagick.c.option;
+
+import core.stdc.stdio;
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum MagickOption
+	{
+		MagickUndefinedOptions = -1,
+		MagickAlignOptions = 0,
+		MagickAlphaOptions,
+		MagickBooleanOptions,
+		MagickChannelOptions,
+		MagickClassOptions,
+		MagickClipPathOptions,
+		MagickCoderOptions,
+		MagickColorOptions,
+		MagickColorspaceOptions,
+		MagickCommandOptions,
+		MagickComposeOptions,
+		MagickCompressOptions,
+		MagickConfigureOptions,
+		MagickDataTypeOptions,
+		MagickDebugOptions,
+		MagickDecorateOptions,
+		MagickDelegateOptions,
+		MagickDirectionOptions,
+		MagickDisposeOptions,
+		MagickDistortOptions,
+		MagickDitherOptions,
+		MagickEndianOptions,
+		MagickEvaluateOptions,
+		MagickFillRuleOptions,
+		MagickFilterOptions,
+		MagickFontOptions,
+		MagickFontsOptions,
+		MagickFormatOptions,
+		MagickFunctionOptions,
+		MagickGravityOptions,
+		MagickImageListOptions,
+		MagickIntentOptions,
+		MagickInterlaceOptions,
+		MagickInterpolateOptions,
+		MagickKernelOptions,
+		MagickLayerOptions,
+		MagickLineCapOptions,
+		MagickLineJoinOptions,
+		MagickListOptions,
+		MagickLocaleOptions,
+		MagickLogEventOptions,
+		MagickLogOptions,
+		MagickMagicOptions,
+		MagickMethodOptions,
+		MagickMetricOptions,
+		MagickMimeOptions,
+		MagickModeOptions,
+		MagickModuleOptions,
+		MagickMorphologyOptions,
+		MagickNoiseOptions,
+		MagickOrientationOptions,
+		MagickPolicyOptions,
+		MagickPolicyDomainOptions,
+		MagickPolicyRightsOptions,
+		MagickPreviewOptions,
+		MagickPrimitiveOptions,
+		MagickQuantumFormatOptions,
+		MagickResolutionOptions,
+		MagickResourceOptions,
+		MagickSparseColorOptions,
+		MagickStorageOptions,
+		MagickStretchOptions,
+		MagickStyleOptions,
+		MagickThresholdOptions,
+		MagickTypeOptions,
+		MagickValidateOptions,
+		MagickVirtualPixelOptions
+	}
+
+	enum ValidateType
+	{
+		UndefinedValidate,
+		NoValidate = 0x00000,
+		CompareValidate = 0x00001,
+		CompositeValidate = 0x00002,
+		ConvertValidate = 0x00004,
+		FormatsInMemoryValidate = 0x00008,
+		FormatsOnDiskValidate = 0x00010,
+		IdentifyValidate = 0x00020,
+		ImportExportValidate = 0x00040,
+		MontageValidate = 0x00080,
+		StreamValidate = 0x00100,
+		AllValidate = 0x7fffffff
+	}
+
+	struct OptionInfo
+	{
+		const(char*)
+			mnemonic;
+
+		ssize_t
+			type;
+
+		MagickBooleanType
+			stealth;
+	}
+
+	char** GetMagickOptions(const MagickOption);
+	char*  GetNextImageOption(const ImageInfo*);
+	char*  RemoveImageOption(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 ListMagickOptions(FILE*, const MagickOption, ExceptionInfo*);
+	MagickBooleanType SetImageOption(ImageInfo*, const char*, 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*);
+}
diff --git a/dmagick/c/paint.d b/dmagick/c/paint.d
new file mode 100644
index 0000000..2b366f5
--- /dev/null
+++ b/dmagick/c/paint.d
@@ -0,0 +1,21 @@
+module dmagick.c.paint;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.draw;
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+
+extern(C)
+{
+	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);
+}
diff --git a/dmagick/c/pixel.d b/dmagick/c/pixel.d
new file mode 100644
index 0000000..95f4cfb
--- /dev/null
+++ b/dmagick/c/pixel.d
@@ -0,0 +1,74 @@
+module dmagick.c.pixel;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.magickType;
+import dmagick.c.colorspace;
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.constitute;
+
+extern(C)
+{
+	struct DoublePixelPacket
+	{
+		double
+			red,
+			green,
+			blue,
+			opacity,
+			index;
+	}
+
+	struct LongPixelPacket
+	{
+		uint
+			red,
+			green,
+			blue,
+			opacity,
+			index;
+	} 
+
+	struct MagickPixelPacket
+	{
+		ClassType
+			storage_class;
+
+		ColorspaceType
+			colorspace;
+
+		MagickBooleanType
+			matte;
+
+		double
+			fuzz;
+
+		size_t
+			depth;
+
+		MagickRealType
+			red,
+			green,
+			blue,
+			opacity,
+			index;
+	}
+
+	alias Quantum IndexPacket;
+
+	struct PixelPacket
+	{
+		Quantum
+			blue,
+			green,
+			red,
+			opacity;
+
+	}
+
+	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*);
+}
diff --git a/dmagick/c/policy.d b/dmagick/c/policy.d
new file mode 100644
index 0000000..733e116
--- /dev/null
+++ b/dmagick/c/policy.d
@@ -0,0 +1,42 @@
+module dmagick.c.policy;
+
+import core.stdc.stdio;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum PolicyDomain
+	{
+		UndefinedPolicyDomain,
+		CoderPolicyDomain,
+		DelegatePolicyDomain,
+		FilterPolicyDomain,
+		PathPolicyDomain,
+		ResourcePolicyDomain,
+		SystemPolicyDomain
+	}
+
+	enum PolicyRights
+	{
+		UndefinedPolicyRights = 0x00,
+		NoPolicyRights = 0x00,
+		ReadPolicyRights = 0x01,
+		WritePolicyRights = 0x02,
+		ExecutePolicyRights = 0x04
+	}
+
+	struct PolicyInfo {}
+
+	char*  GetPolicyValue(const char* name);
+	char** GetPolicyList(const char*, size_t*, ExceptionInfo*);
+
+	const(PolicyInfo**) GetPolicyInfoList(const char*, size_t*, ExceptionInfo*);
+
+	MagickBooleanType IsRightsAuthorized(const PolicyDomain, const PolicyRights, const char*);
+	MagickBooleanType ListPolicyInfo(FILE*, ExceptionInfo*);
+	MagickBooleanType PolicyComponentGenesis();
+
+	void PolicyComponentTerminus();
+}
diff --git a/dmagick/c/prepress.d b/dmagick/c/prepress.d
new file mode 100644
index 0000000..2a53d7e
--- /dev/null
+++ b/dmagick/c/prepress.d
@@ -0,0 +1,5 @@
+module dmagick.c.prepress;
+
+import dmagick.c.image;
+
+extern(C) double GetImageTotalInkDensity(Image* image);
diff --git a/dmagick/c/profile.d b/dmagick/c/profile.d
new file mode 100644
index 0000000..44dbbf6
--- /dev/null
+++ b/dmagick/c/profile.d
@@ -0,0 +1,47 @@
+module dmagick.c.profile;
+
+import dmagick.c.magickString;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct ProfileInfo
+	{
+		char*
+			name;
+
+		size_t
+			length;
+
+		ubyte*
+			info;
+
+		size_t
+			signature;
+	}
+
+	enum RenderingIntent
+	{
+		UndefinedIntent,
+		SaturationIntent,
+		PerceptualIntent,
+		AbsoluteIntent,
+		RelativeIntent
+	}
+
+	char* GetNextImageProfile(const Image*);
+
+	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 SyncImageProfiles(Image*);
+
+	StringInfo* RemoveImageProfile(Image*, const char*);
+
+	void DestroyImageProfiles(Image*);
+	void ResetImageProfileIterator(const Image*);
+}
diff --git a/dmagick/c/property.d b/dmagick/c/property.d
new file mode 100644
index 0000000..1fd6193
--- /dev/null
+++ b/dmagick/c/property.d
@@ -0,0 +1,26 @@
+module dmagick.c.property;
+
+import core.vararg;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	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*);
+
+	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*);
+}
diff --git a/dmagick/c/quantize.d b/dmagick/c/quantize.d
new file mode 100644
index 0000000..72584e2
--- /dev/null
+++ b/dmagick/c/quantize.d
@@ -0,0 +1,54 @@
+module dmagick.c.quantize;
+
+import dmagick.c.colorspace;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum DitherMethod
+	{
+		UndefinedDitherMethod,
+		NoDitherMethod,
+		RiemersmaDitherMethod,
+		FloydSteinbergDitherMethod
+	}
+
+	struct QuantizeInfo
+	{
+		size_t
+			number_colors;
+
+		size_t
+			tree_depth;
+
+		MagickBooleanType
+			dither;
+
+		ColorspaceType
+			colorspace;
+
+		MagickBooleanType
+			measure_error;
+
+		size_t
+			signature;
+
+		DitherMethod
+			dither_method;
+	}
+
+	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*);
+
+	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
new file mode 100644
index 0000000..5d534dd
--- /dev/null
+++ b/dmagick/c/quantum.d
@@ -0,0 +1,103 @@
+module dmagick.c.quantum;
+
+import dmagick.c.cacheView;
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum EndianType
+	{
+		UndefinedEndian,
+		LSBEndian,
+		MSBEndian
+	}
+
+	enum QuantumAlphaType
+	{
+		UndefinedQuantumAlpha,
+		AssociatedQuantumAlpha,
+		DisassociatedQuantumAlpha
+	}
+
+	enum QuantumFormatType
+	{
+		UndefinedQuantumFormat,
+		FloatingPointQuantumFormat,
+		SignedQuantumFormat,
+		UnsignedQuantumFormat
+	}
+
+	enum QuantumType
+	{
+		UndefinedQuantum,
+		AlphaQuantum,
+		BlackQuantum,
+		BlueQuantum,
+		CMYKAQuantum,
+		CMYKQuantum,
+		CyanQuantum,
+		GrayAlphaQuantum,
+		GrayQuantum,
+		GreenQuantum,
+		IndexAlphaQuantum,
+		IndexQuantum,
+		MagentaQuantum,
+		OpacityQuantum,
+		RedQuantum,
+		RGBAQuantum,
+		BGRAQuantum,
+		RGBOQuantum,
+		RGBQuantum,
+		YellowQuantum,
+		GrayPadQuantum,
+		RGBPadQuantum,
+		CbYCrYQuantum,
+		CbYCrQuantum,
+		CbYCrAQuantum,
+		CMYKOQuantum,
+		BGRQuantum,
+		BGROQuantum
+	}
+
+	struct QuantumInfo {}
+
+	alias ClampToQuantum RoundToQuantum;
+	static pure nothrow Quantum ClampToQuantum(const MagickRealType value)
+	{
+		if (value <= 0.0)
+			return(cast(Quantum) 0);
+		if (value >= cast(MagickRealType) 65535UL)
+			return(cast(Quantum) 65535UL);
+		return(cast(Quantum) (value+0.5));
+	}
+
+	static pure nothrow ubyte ScaleQuantumToChar(const Quantum quantum)
+	{
+		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);
+
+	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*);
+
+	ubyte* GetQuantumPixels(const QuantumInfo*);
+
+	void GetQuantumInfo(const ImageInfo*, QuantumInfo*);
+	void SetQuantumAlphaType(QuantumInfo*, const QuantumAlphaType);
+	void SetQuantumImageType(Image*, const QuantumType);
+	void SetQuantumMinIsWhite(QuantumInfo*, const MagickBooleanType);
+	void SetQuantumPack(QuantumInfo*, const MagickBooleanType);
+	void SetQuantumQuantum(QuantumInfo*, const size_t);
+	void SetQuantumScale(QuantumInfo*, const double);
+}
diff --git a/dmagick/c/random.d b/dmagick/c/random.d
new file mode 100644
index 0000000..4af5ffd
--- /dev/null
+++ b/dmagick/c/random.d
@@ -0,0 +1,24 @@
+module dmagick.c.random;
+
+import dmagick.c.magickString;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct RandomInfo {}
+
+	double GetRandomValue(RandomInfo*);
+	double GetPseudoRandomValue(RandomInfo*);
+
+	MagickBooleanType RandomComponentGenesis();
+
+	RandomInfo* AcquireRandomInfo();
+	RandomInfo* DestroyRandomInfo(RandomInfo*);
+
+	StringInfo* GetRandomKey(RandomInfo*, const size_t);
+
+	void RandomComponentTerminus();
+	void SeedPseudoRandomGenerator(const size_t);
+	void SetRandomKey(RandomInfo*, const size_t, ubyte*);
+	void SetRandomTrueRandom(const MagickBooleanType);
+}
diff --git a/dmagick/c/registry.d b/dmagick/c/registry.d
new file mode 100644
index 0000000..38ae2fe
--- /dev/null
+++ b/dmagick/c/registry.d
@@ -0,0 +1,27 @@
+module dmagick.c.registry;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum RegistryType
+	{
+		UndefinedRegistryType,
+		ImageRegistryType,
+		ImageInfoRegistryType,
+		StringRegistryType
+	}
+
+	char* GetNextImageRegistry();
+
+	MagickBooleanType DefineImageRegistry(const RegistryType, const char*, ExceptionInfo*);
+	MagickBooleanType DeleteImageRegistry(const char*);
+	MagickBooleanType RegistryComponentGenesis();
+	MagickBooleanType SetImageRegistry(const RegistryType, const char*, const void*, ExceptionInfo*);
+
+	void* GetImageRegistry(const RegistryType, const char*, ExceptionInfo*);
+	void  RegistryComponentTerminus();
+	void* RemoveImageRegistry(const char*);
+	void  ResetImageRegistryIterator();
+}
diff --git a/dmagick/c/resample.d b/dmagick/c/resample.d
new file mode 100644
index 0000000..77fc6b1
--- /dev/null
+++ b/dmagick/c/resample.d
@@ -0,0 +1,65 @@
+module dmagick.c.resample;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+import dmagick.c.cacheView;
+
+extern(C)
+{
+	enum FilterTypes
+	{
+		UndefinedFilter,
+		PointFilter,
+		BoxFilter,
+		TriangleFilter,
+		HermiteFilter,
+		HanningFilter,
+		HammingFilter,
+		BlackmanFilter,
+		GaussianFilter,
+		QuadraticFilter,
+		CubicFilter,
+		CatromFilter,
+		MitchellFilter,
+		LanczosFilter,
+		JincFilter,
+		SincFilter,
+		KaiserFilter,
+		WelshFilter,
+		ParzenFilter,
+		LagrangeFilter,
+		BohmanFilter,
+		BartlettFilter,
+		SincFastFilter,
+		Lanczos2DFilter,
+		RobidouxFilter,
+		SentinelFilter
+	}
+
+	enum InterpolatePixelMethod
+	{
+		UndefinedInterpolatePixel,
+		AverageInterpolatePixel,
+		BicubicInterpolatePixel,
+		BilinearInterpolatePixel,
+		FilterInterpolatePixel,
+		IntegerInterpolatePixel,
+		MeshInterpolatePixel,
+		NearestNeighborInterpolatePixel,
+		SplineInterpolatePixel
+	}
+
+	struct ResampleFilter {}
+
+	MagickBooleanType ResamplePixelColor(ResampleFilter*, const double, const double, MagickPixelPacket*);
+	MagickBooleanType SetResampleFilterInterpolateMethod(ResampleFilter*, const InterpolatePixelMethod);
+	MagickBooleanType SetResampleFilterVirtualPixelMethod(ResampleFilter*, const VirtualPixelMethod);
+
+	ResampleFilter* AcquireResampleFilter(const Image*, ExceptionInfo*);
+	ResampleFilter* DestroyResampleFilter(ResampleFilter*);
+
+	void ScaleResampleFilter(ResampleFilter*, const double, const double, const double, const double);
+	void SetResampleFilter(ResampleFilter*, const FilterTypes, const double);
+}
diff --git a/dmagick/c/resize.d b/dmagick/c/resize.d
new file mode 100644
index 0000000..7a4aaba
--- /dev/null
+++ b/dmagick/c/resize.d
@@ -0,0 +1,18 @@
+module dmagick.c.resize;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+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*);
+}
diff --git a/dmagick/c/resource.d b/dmagick/c/resource.d
new file mode 100644
index 0000000..1e97a59
--- /dev/null
+++ b/dmagick/c/resource.d
@@ -0,0 +1,37 @@
+module dmagick.c.resource;
+
+import core.stdc.stdio;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum ResourceType
+	{
+		UndefinedResource,
+		AreaResource,
+		DiskResource,
+		FileResource,
+		MapResource,
+		MemoryResource,
+		ThreadResource,
+		TimeResource,
+		ThrottleResource
+	}
+
+	int AcquireUniqueFileResource(char*);
+
+	MagickBooleanType AcquireMagickResource(const ResourceType, const MagickSizeType);
+	MagickBooleanType ListMagickResourceInfo(FILE*, ExceptionInfo*);
+	MagickBooleanType RelinquishUniqueFileResource(const char*);
+	MagickBooleanType ResourceComponentGenesis();
+	MagickBooleanType SetMagickResourceLimit(const ResourceType, const MagickSizeType);
+
+	MagickSizeType GetMagickResource(const ResourceType);
+	MagickSizeType GetMagickResourceLimit(const ResourceType);
+
+	void AsynchronousResourceComponentTerminus();
+	void RelinquishMagickResource(const ResourceType, const MagickSizeType);
+	void ResourceComponentTerminus();
+}
diff --git a/dmagick/c/segment.d b/dmagick/c/segment.d
new file mode 100644
index 0000000..3f04bfa
--- /dev/null
+++ b/dmagick/c/segment.d
@@ -0,0 +1,13 @@
+module dmagick.c.segment;
+
+import dmagick.c.colorspace;
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+import dmagick.c.pixel;
+
+extern(C)
+{
+	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/semaphore.d b/dmagick/c/semaphore.d
new file mode 100644
index 0000000..92ed1ed
--- /dev/null
+++ b/dmagick/c/semaphore.d
@@ -0,0 +1,19 @@
+module dmagick.c.semaphore;
+
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct SemaphoreInfo {}
+
+	MagickBooleanType SemaphoreComponentGenesis();
+
+	SemaphoreInfo* AllocateSemaphoreInfo();
+
+	void AcquireSemaphoreInfo(SemaphoreInfo**);
+	void DestroySemaphoreInfo(SemaphoreInfo**);
+	void LockSemaphoreInfo(SemaphoreInfo*);
+	void RelinquishSemaphoreInfo(SemaphoreInfo*);
+	void SemaphoreComponentTerminus();
+	void UnlockSemaphoreInfo(SemaphoreInfo*);
+}
diff --git a/dmagick/c/sheer.d b/dmagick/c/sheer.d
new file mode 100644
index 0000000..6555e65
--- /dev/null
+++ b/dmagick/c/sheer.d
@@ -0,0 +1,13 @@
+module dmagick.c.sheer;
+
+import dmagick.c.exception;
+import dmagick.c.geometry;
+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*);
+}
diff --git a/dmagick/c/signature.d b/dmagick/c/signature.d
new file mode 100644
index 0000000..3d75b58
--- /dev/null
+++ b/dmagick/c/signature.d
@@ -0,0 +1,6 @@
+module dmagick.c.signature;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C) MagickBooleanType SignatureImage(Image*);
diff --git a/dmagick/c/splayTree.d b/dmagick/c/splayTree.d
new file mode 100644
index 0000000..77c8489
--- /dev/null
+++ b/dmagick/c/splayTree.d
@@ -0,0 +1,30 @@
+module dmagick.c.splayTree;
+
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct SplayTreeInfo {}
+
+	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*);
+
+	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*));
+
+	size_t GetNumberOfNodesInSplayTree(const SplayTreeInfo*);
+
+	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
new file mode 100644
index 0000000..b63a184
--- /dev/null
+++ b/dmagick/c/statistic.d
@@ -0,0 +1,86 @@
+module dmagick.c.statistic;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct ChannelStatistics
+	{
+		size_t
+			depth;
+
+		double
+			minima,
+			maxima,
+			sum,
+			sum_squared,
+			sum_cubed,
+			sum_fourth_power,
+			mean,
+			variance,
+			standard_deviation,
+			kurtosis,
+			skewness;
+	}
+
+	enum MagickEvaluateOperator
+	{
+		UndefinedEvaluateOperator,
+		AddEvaluateOperator,
+		AndEvaluateOperator,
+		DivideEvaluateOperator,
+		LeftShiftEvaluateOperator,
+		MaxEvaluateOperator,
+		MinEvaluateOperator,
+		MultiplyEvaluateOperator,
+		OrEvaluateOperator,
+		RightShiftEvaluateOperator,
+		SetEvaluateOperator,
+		SubtractEvaluateOperator,
+		XorEvaluateOperator,
+		PowEvaluateOperator,
+		LogEvaluateOperator,
+		ThresholdEvaluateOperator,
+		ThresholdBlackEvaluateOperator,
+		ThresholdWhiteEvaluateOperator,
+		GaussianNoiseEvaluateOperator,
+		ImpulseNoiseEvaluateOperator,
+		LaplacianNoiseEvaluateOperator,
+		MultiplicativeNoiseEvaluateOperator,
+		PoissonNoiseEvaluateOperator,
+		UniformNoiseEvaluateOperator,
+		CosineEvaluateOperator,
+		SineEvaluateOperator,
+		AddModulusEvaluateOperator,
+		MeanEvaluateOperator,
+		AbsEvaluateOperator
+	}
+
+	enum MagickFunction
+	{
+		UndefinedFunction,
+		PolynomialFunction,
+		SinusoidFunction,
+		ArcsinFunction,
+		ArctanFunction
+	}
+
+	ChannelStatistics* GetImageChannelStatistics(const Image*, 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*);
+}
diff --git a/dmagick/c/stream.d b/dmagick/c/stream.d
new file mode 100644
index 0000000..788ca72
--- /dev/null
+++ b/dmagick/c/stream.d
@@ -0,0 +1,14 @@
+module dmagick.c.stream;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	alias size_t function(const Image *,const void *,const size_t) StreamHandler;
+
+	Image* ReadStream(const ImageInfo*, StreamHandler, ExceptionInfo*);
+
+	MagickBooleanType WriteStream(const ImageInfo*, Image*, StreamHandler);
+}
diff --git a/dmagick/c/threshold.d b/dmagick/c/threshold.d
new file mode 100644
index 0000000..4134b13
--- /dev/null
+++ b/dmagick/c/threshold.d
@@ -0,0 +1,34 @@
+module dmagick.c.threshold;
+
+import core.stdc.stdio;
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct ThresholdMap {}
+
+	Image* AdaptiveThresholdImage(const Image*, const size_t, const size_t, const ssize_t, ExceptionInfo*);
+
+	ThresholdMap* DestroyThresholdMap(ThresholdMap*);
+	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 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 *);
+}
diff --git a/dmagick/c/timer.d b/dmagick/c/timer.d
new file mode 100644
index 0000000..36603ce
--- /dev/null
+++ b/dmagick/c/timer.d
@@ -0,0 +1,46 @@
+module dmagick.c.timer;
+
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum TimerState
+	{
+		UndefinedTimerState,
+		StoppedTimerState,
+		RunningTimerState
+	}
+
+	struct Timer
+	{
+		double
+			start,
+			stop,
+			total;
+	}
+
+	struct TimerInfo
+	{
+		Timer
+			user,
+			elapsed;
+
+		TimerState
+			state;
+
+		size_t
+			signature;
+	}
+
+	double GetElapsedTime(TimerInfo*);
+	double GetUserTime(TimerInfo*);
+
+	MagickBooleanType ContinueTimer(TimerInfo*);
+
+	TimerInfo* AcquireTimerInfo();
+	TimerInfo* DestroyTimerInfo(TimerInfo*);
+
+	void GetTimerInfo(TimerInfo*);
+	void ResetTimer(TimerInfo*);
+	void StartTimer(TimerInfo*, const MagickBooleanType);
+}
diff --git a/dmagick/c/token.d b/dmagick/c/token.d
new file mode 100644
index 0000000..007cc98
--- /dev/null
+++ b/dmagick/c/token.d
@@ -0,0 +1,19 @@
+module dmagick.c.token;
+
+import dmagick.c.magickType;
+
+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*);
+
+	MagickBooleanType GlobExpression(const char*, const char*, const MagickBooleanType);
+	MagickBooleanType IsGlob(const char*);
+
+	TokenInfo* AcquireTokenInfo();
+	TokenInfo* DestroyTokenInfo(TokenInfo*);
+
+	void GetMagickToken(const char*, const char**, char*);
+}
diff --git a/dmagick/c/transform.d b/dmagick/c/transform.d
new file mode 100644
index 0000000..462d1a9
--- /dev/null
+++ b/dmagick/c/transform.d
@@ -0,0 +1,28 @@
+module dmagick.c.transform;
+
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.geometry;
+import dmagick.c.image;
+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*);
+
+	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
new file mode 100644
index 0000000..2365443
--- /dev/null
+++ b/dmagick/c/type.d
@@ -0,0 +1,82 @@
+module dmagick.c.type;
+
+import core.stdc.stdio;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum StretchType
+	{
+		UndefinedStretch,
+		NormalStretch,
+		UltraCondensedStretch,
+		ExtraCondensedStretch,
+		CondensedStretch,
+		SemiCondensedStretch,
+		SemiExpandedStretch,
+		ExpandedStretch,
+		ExtraExpandedStretch,
+		UltraExpandedStretch,
+		AnyStretch
+	}
+
+	enum StyleType
+	{
+		UndefinedStyle,
+		NormalStyle,
+		ItalicStyle,
+		ObliqueStyle,
+		AnyStyle
+	}
+
+	struct TypeInfo
+	{
+		size_t
+			face;
+
+		char*
+			path,
+			name,
+			description,
+			family;
+
+		StyleType
+			style;
+
+		StretchType
+			stretch;
+
+		size_t
+			weight;
+
+		char*
+			encoding,
+			foundry,
+			format,
+			metrics,
+			glyphs;
+
+		MagickBooleanType
+			stealth;
+
+		TypeInfo*
+			previous,
+			next;
+
+		size_t
+			signature;
+	}
+
+	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*);
+
+	void TypeComponentTerminus();
+}
diff --git a/dmagick/c/utility.d b/dmagick/c/utility.d
new file mode 100644
index 0000000..bc4e2db
--- /dev/null
+++ b/dmagick/c/utility.d
@@ -0,0 +1,51 @@
+module dmagick.c.utility;
+
+import core.stdc.stdio;
+import core.sys.posix.sys.types;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	enum PathType
+	{
+		UndefinedPath,
+		MagickPath,
+		RootPath,
+		HeadPath,
+		TailPath,
+		BasePath,
+		ExtensionPath,
+		SubimagePath,
+		CanonicalPath
+	}
+
+	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*);
+
+	int SystemCommand(const MagickBooleanType, const MagickBooleanType, const char*, ExceptionInfo*);
+
+	MagickBooleanType AcquireUniqueFilename(char*);
+	MagickBooleanType AcquireUniqueSymbolicLink(const char*, char*);
+	MagickBooleanType ExpandFilenames(int*, char***);
+	MagickBooleanType GetPathAttributes(const char*, void*);
+	MagickBooleanType GetExecutionPath(char*, const size_t);
+	MagickBooleanType IsMagickTrue(const char*);
+	MagickBooleanType IsPathAccessible(const char*);
+
+	size_t MultilineCensus(const char*);
+
+	ssize_t GetMagickPageSize();
+
+	ubyte* Base64Decode(const char*, size_t*);
+
+	void AppendImageFormat(const char*, char*);
+	void ChopPathComponents(char*, const size_t);
+	void ExpandFilename(char*);
+	void GetPathComponent(const char*, PathType, char*);
+	void MagickDelay(const MagickSizeType);
+}
diff --git a/dmagick/c/xmlTree.d b/dmagick/c/xmlTree.d
new file mode 100644
index 0000000..dc1bbbb
--- /dev/null
+++ b/dmagick/c/xmlTree.d
@@ -0,0 +1,36 @@
+module dmagick.c.xmlTree;
+
+import dmagick.c.exception;
+import dmagick.c.magickType;
+import dmagick.c.splayTree;
+
+extern(C)
+{
+	struct XMLTreeInfo {}
+
+	char* CanonicalXMLContent(const char*, const MagickBooleanType);
+	char* XMLTreeInfoToXML(XMLTreeInfo*);
+
+	const(char*)  GetXMLTreeAttribute(XMLTreeInfo*, const char*);
+	const(char*)  GetXMLTreeContent(XMLTreeInfo*);
+	const(char**) GetXMLTreeProcessingInstructions(XMLTreeInfo*, const char*);
+	const(char*)  GetXMLTreeTag(XMLTreeInfo*);
+
+	MagickBooleanType GetXMLTreeAttributes(const XMLTreeInfo*, SplayTreeInfo*);
+
+	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* GetXMLTreeOrdered(XMLTreeInfo*);
+	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* ParseTagFromXMLTree(XMLTreeInfo*);
+	XMLTreeInfo* PruneTagFromXMLTree(XMLTreeInfo*);
+	XMLTreeInfo* SetXMLTreeAttribute(XMLTreeInfo*, const char*, const char*);
+	XMLTreeInfo* SetXMLTreeContent(XMLTreeInfo*, const char*);
+}
diff --git a/dmagick/c/xwindow.d b/dmagick/c/xwindow.d
new file mode 100644
index 0000000..80b416a
--- /dev/null
+++ b/dmagick/c/xwindow.d
@@ -0,0 +1,21 @@
+module dmagick.c.xwindow;
+
+import dmagick.c.image;
+import dmagick.c.magickType;
+
+extern(C)
+{
+	struct XImportInfo
+	{
+	  MagickBooleanType
+		frame,
+		borders,
+		screen,
+		descend,
+		silent;
+	}
+
+	Image* XImportImage(const ImageInfo*, XImportInfo*);
+
+	void XGetImportInfo(XImportInfo*);
+}