diff --git a/src/main/java/com/justinefactory/cloud/communication/service/CloudObjectTransferService.java b/src/main/java/com/justinefactory/cloud/communication/service/CloudObjectTransferService.java
new file mode 100644
index 0000000..3ae3f39
--- /dev/null
+++ b/src/main/java/com/justinefactory/cloud/communication/service/CloudObjectTransferService.java
@@ -0,0 +1,35 @@
+package com.justinefactory.cloud.communication.service;
+
+
+import com.justinefactory.cloud.communication.transfer.CloudObjectContentGetter;
+import com.justinefactory.deserialization.deserializers.Deserializer;
+import com.justinefactory.domain.AwsInfo;
+import com.justinefactory.reading.exceptions.AwsContentReadingException;
+import com.justinefactory.reading.exceptions.ContentDeserializationException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+
+class CloudObjectTransferService<ContentType, DeserializedContent> {
+
+    private final CloudObjectContentGetter<ContentType> cloudObjectContentGetter;
+    private final Deserializer<ContentType, DeserializedContent> deserializer;
+    private static final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
+
+    CloudObjectTransferService(CloudObjectContentGetter<ContentType> cloudObjectContentGetter, Deserializer<ContentType, DeserializedContent> deserializer) {
+        logger.info("Transfer service - initialization");
+        this.cloudObjectContentGetter = cloudObjectContentGetter;
+        this.deserializer = deserializer;
+    }
+
+    public DeserializedContent getAndDeserializeCloudObject(AwsInfo info, Class<DeserializedContent> classToDeserialize) throws IOException, AwsContentReadingException, ContentDeserializationException {
+        ContentType input = cloudObjectContentGetter.getObjectContent(info);
+        logger.debug("Transfer Service - extracting content from cloud object - success.");
+        DeserializedContent deserializedContent = deserializer.deserialize(input, classToDeserialize);
+        logger.info("Transfer Service - finished with success.");
+        return deserializedContent;
+    }
+
+}
diff --git a/src/main/java/com/justinefactory/cloud/communication/distribution/service/CloudObjectsManagementService.java b/src/main/java/com/justinefactory/cloud/communication/service/CloudObjectsManagementService.java
similarity index 77%
rename from src/main/java/com/justinefactory/cloud/communication/distribution/service/CloudObjectsManagementService.java
rename to src/main/java/com/justinefactory/cloud/communication/service/CloudObjectsManagementService.java
index 4863989..9e6c7e1 100644
--- a/src/main/java/com/justinefactory/cloud/communication/distribution/service/CloudObjectsManagementService.java
+++ b/src/main/java/com/justinefactory/cloud/communication/service/CloudObjectsManagementService.java
@@ -1,4 +1,4 @@
-package com.justinefactory.cloud.communication.distribution.service;
+package com.justinefactory.cloud.communication.service;
 
 import com.amazonaws.services.s3.AmazonS3;
 import com.justinefactory.cloud.communication.distribution.ServerObjectDownloadByUrlCreator;
@@ -6,7 +6,7 @@
 import com.justinefactory.reading.exceptions.ContentReadingException;
 import com.justinefactory.sending.service.ContentSendingService;
 import com.justinefactory.stats.exceptions.StatsCalculatingException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import com.justinefactory.writing.exceptions.ContentWritingException;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -14,13 +14,13 @@
 import java.lang.invoke.MethodHandles;
 import java.time.Duration;
 
-public class CloudObjectsManagementService<RawContent, Content> {
+public class CloudObjectsManagementService<RawContentType, ContentType> {
 
-    private final ContentSendingService<RawContent, Content, ContentStorage<String>> sendingService;
+    private final ContentSendingService<RawContentType, ContentType, Content<String>> sendingService;
     private final ServerObjectDownloadByUrlCreator urlCreator;
     private static final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
-    public CloudObjectsManagementService(ContentSendingService<RawContent, Content, ContentStorage<String>> sendingService, ServerObjectDownloadByUrlCreator urlCreator) {
+    public CloudObjectsManagementService(ContentSendingService<RawContentType, ContentType, Content<String>> sendingService, ServerObjectDownloadByUrlCreator urlCreator) {
         logger.debug("Creating, sending and management of server objects - initialization");
         this.sendingService = sendingService;
         this.urlCreator = urlCreator;
diff --git a/src/main/java/com/justinefactory/cloud/communication/transfer/CloudObjectContentGetter.java b/src/main/java/com/justinefactory/cloud/communication/transfer/CloudObjectContentGetter.java
new file mode 100644
index 0000000..2378cf6
--- /dev/null
+++ b/src/main/java/com/justinefactory/cloud/communication/transfer/CloudObjectContentGetter.java
@@ -0,0 +1,11 @@
+package com.justinefactory.cloud.communication.transfer;
+
+import com.justinefactory.domain.AwsInfo;
+import com.justinefactory.reading.exceptions.AwsContentReadingException;
+
+import java.io.IOException;
+
+public interface CloudObjectContentGetter<ContentType> {
+
+    ContentType getObjectContent(AwsInfo info) throws IOException, AwsContentReadingException;
+}
diff --git a/src/main/java/com/justinefactory/cloud/communication/transfer/ContentExtractor.java b/src/main/java/com/justinefactory/cloud/communication/transfer/ContentExtractor.java
new file mode 100644
index 0000000..b0529d4
--- /dev/null
+++ b/src/main/java/com/justinefactory/cloud/communication/transfer/ContentExtractor.java
@@ -0,0 +1,9 @@
+package com.justinefactory.cloud.communication.transfer;
+
+import com.justinefactory.reading.exceptions.AwsContentReadingException;
+
+public interface ContentExtractor<Object, ContentType> {
+
+    ContentType extractContent(Object object) throws AwsContentReadingException;
+
+}
diff --git a/src/main/java/com/justinefactory/cloud/communication/transfer/ContentExtractorFromS3ObjectInputStream.java b/src/main/java/com/justinefactory/cloud/communication/transfer/ContentExtractorFromS3ObjectInputStream.java
new file mode 100644
index 0000000..7f11bee
--- /dev/null
+++ b/src/main/java/com/justinefactory/cloud/communication/transfer/ContentExtractorFromS3ObjectInputStream.java
@@ -0,0 +1,7 @@
+package com.justinefactory.cloud.communication.transfer;
+
+import com.amazonaws.services.s3.model.S3ObjectInputStream;
+
+public interface ContentExtractorFromS3ObjectInputStream<ContentType> extends ContentExtractor<S3ObjectInputStream, ContentType> {
+
+}
diff --git a/src/main/java/com/justinefactory/cloud/communication/transfer/JsonExtractorFromS3ObjectInputStream.java b/src/main/java/com/justinefactory/cloud/communication/transfer/JsonExtractorFromS3ObjectInputStream.java
new file mode 100644
index 0000000..77be433
--- /dev/null
+++ b/src/main/java/com/justinefactory/cloud/communication/transfer/JsonExtractorFromS3ObjectInputStream.java
@@ -0,0 +1,29 @@
+package com.justinefactory.cloud.communication.transfer;
+
+import com.amazonaws.services.s3.model.S3ObjectInputStream;
+import com.amazonaws.util.IOUtils;
+import com.justinefactory.reading.exceptions.AwsContentReadingException;
+import com.justinefactory.writing.domain.JsonContent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+
+
+public class JsonExtractorFromS3ObjectInputStream implements ContentExtractorFromS3ObjectInputStream<JsonContent> {
+
+    private final Logger logger = LogManager.getLogger(this.getClass());
+
+    @Override
+    public JsonContent extractContent(S3ObjectInputStream inputStream) throws AwsContentReadingException {
+        if (inputStream == null) {
+            throw new AwsContentReadingException("Trouble while processing inputStream - input was empty.");
+        }
+        try {
+            return new JsonContent(IOUtils.toString(inputStream));
+        } catch (IOException e) {
+            logger.warn("Trouble while extracting json object from inputStream {}", inputStream, e);
+            throw new AwsContentReadingException(e, "Trouble while extracting json object from inputStream " + inputStream);
+        }
+    }
+}
diff --git a/src/main/java/com/justinefactory/cloud/communication/transfer/S3CloudObjectContentGetter.java b/src/main/java/com/justinefactory/cloud/communication/transfer/S3CloudObjectContentGetter.java
new file mode 100644
index 0000000..0a65a5e
--- /dev/null
+++ b/src/main/java/com/justinefactory/cloud/communication/transfer/S3CloudObjectContentGetter.java
@@ -0,0 +1,39 @@
+package com.justinefactory.cloud.communication.transfer;
+
+import com.amazonaws.AmazonServiceException;
+import com.amazonaws.SdkClientException;
+import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.model.GetObjectRequest;
+import com.amazonaws.services.s3.model.S3ObjectInputStream;
+import com.justinefactory.domain.AwsInfo;
+import com.justinefactory.reading.exceptions.AwsContentReadingException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+
+
+public class S3CloudObjectContentGetter<ContentType> implements CloudObjectContentGetter<ContentType> {
+
+    private final AmazonS3 client;
+    private final ContentExtractorFromS3ObjectInputStream<ContentType> contentExtractor;
+    private final Logger logger = LogManager.getLogger(this.getClass());
+
+    public S3CloudObjectContentGetter(AmazonS3 awsClient, ContentExtractorFromS3ObjectInputStream<ContentType> contentExtractor) {
+        client = awsClient;
+        this.contentExtractor = contentExtractor;
+    }
+
+    @Override
+    public ContentType getObjectContent(AwsInfo info) throws IOException, AwsContentReadingException {
+        try (S3ObjectInputStream inputStream = client.getObject(new GetObjectRequest(info.getBucketName(), info.getKeyName())).getObjectContent()) {
+            return contentExtractor.extractContent(inputStream);
+        } catch (AmazonServiceException e) {
+            logger.warn("Trouble with Amazon S3 while processing get request of {}.", info.getURI());
+            throw new AmazonServiceException("Trouble with Amazon S3 while processing request on ." + info.getURI(), e);
+        } catch (SdkClientException e) {
+            logger.warn("Trouble with Amazon S3 connection while processing get request on {}.", info.getURI());
+            throw new SdkClientException("Trouble with Amazon S3 connection.", e);
+        }
+    }
+}
diff --git a/src/main/java/com/justinefactory/deserialization/deserializers/Deserializer.java b/src/main/java/com/justinefactory/deserialization/deserializers/Deserializer.java
new file mode 100644
index 0000000..14059b3
--- /dev/null
+++ b/src/main/java/com/justinefactory/deserialization/deserializers/Deserializer.java
@@ -0,0 +1,11 @@
+package com.justinefactory.deserialization.deserializers;
+
+import com.justinefactory.reading.exceptions.ContentDeserializationException;
+
+import java.lang.reflect.Type;
+
+public interface Deserializer<Object, ContentType> {
+
+    ContentType deserialize(Object object, Class<ContentType> type) throws ContentDeserializationException;
+
+}
diff --git a/src/main/java/com/justinefactory/deserialization/deserializers/JsonDeserializer.java b/src/main/java/com/justinefactory/deserialization/deserializers/JsonDeserializer.java
new file mode 100644
index 0000000..6457b1a
--- /dev/null
+++ b/src/main/java/com/justinefactory/deserialization/deserializers/JsonDeserializer.java
@@ -0,0 +1,24 @@
+package com.justinefactory.deserialization.deserializers;
+
+import com.google.gson.Gson;
+import com.justinefactory.reading.exceptions.ContentDeserializationException;
+import com.justinefactory.writing.domain.JsonContent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class JsonDeserializer<ContentType> implements Deserializer<JsonContent, ContentType> {
+
+    private final Logger logger = LogManager.getLogger(this.getClass());
+
+    @Override
+    public ContentType deserialize(JsonContent jsonContent, Class<ContentType> classTypeToDeserializeJson) throws ContentDeserializationException {
+        Gson gson = new Gson();
+        try {
+            return gson.fromJson(jsonContent.getContent(), classTypeToDeserializeJson);
+        } catch (Throwable e) {
+            logger.warn("Trouble while performing deserialization of json: {}", jsonContent.getContent(), e);
+            throw new ContentDeserializationException(e, "Trouble while performing deserialization of json: " + jsonContent.getContent());
+        }
+    }
+
+}
diff --git a/src/main/java/com/justinefactory/reading/exceptions/AwsContentReadingException.java b/src/main/java/com/justinefactory/reading/exceptions/AwsContentReadingException.java
new file mode 100644
index 0000000..dc352bc
--- /dev/null
+++ b/src/main/java/com/justinefactory/reading/exceptions/AwsContentReadingException.java
@@ -0,0 +1,16 @@
+package com.justinefactory.reading.exceptions;
+
+public class AwsContentReadingException extends ContentReadingException {
+
+    public AwsContentReadingException(Throwable cause) {
+        super(cause);
+    }
+
+    public AwsContentReadingException(Throwable cause, String message) {
+        super(cause, message);
+    }
+
+    public AwsContentReadingException(String message) {
+        super(message);
+    }
+}
diff --git a/src/main/java/com/justinefactory/reading/exceptions/ContentDeserializationException.java b/src/main/java/com/justinefactory/reading/exceptions/ContentDeserializationException.java
new file mode 100644
index 0000000..376c018
--- /dev/null
+++ b/src/main/java/com/justinefactory/reading/exceptions/ContentDeserializationException.java
@@ -0,0 +1,8 @@
+package com.justinefactory.reading.exceptions;
+
+public class ContentDeserializationException extends ContentReadingException {
+
+    public ContentDeserializationException(Throwable cause, String message) {
+        super(cause, message);
+    }
+}
diff --git a/src/main/java/com/justinefactory/reading/parsers/ContentParser.java b/src/main/java/com/justinefactory/reading/parsers/ContentParser.java
index dd344be..bd69dfd 100644
--- a/src/main/java/com/justinefactory/reading/parsers/ContentParser.java
+++ b/src/main/java/com/justinefactory/reading/parsers/ContentParser.java
@@ -1,8 +1,9 @@
 package com.justinefactory.reading.parsers;
 
 import com.justinefactory.reading.exceptions.ContentParsingException;
+import com.justinefactory.writing.domain.Content;
 
-public interface ContentParser<Line, Content> {
+public interface ContentParser<RawContent, ContentType> {
 
-    public Content parseLine(Line line) throws ContentParsingException;
+    Content<ContentType> parse(RawContent rawContent) throws ContentParsingException;
 }
diff --git a/src/main/java/com/justinefactory/reading/parsers/CsvLineParser.java b/src/main/java/com/justinefactory/reading/parsers/CsvLineParser.java
index 3ecb786..c9ba23d 100644
--- a/src/main/java/com/justinefactory/reading/parsers/CsvLineParser.java
+++ b/src/main/java/com/justinefactory/reading/parsers/CsvLineParser.java
@@ -1,5 +1,7 @@
 package com.justinefactory.reading.parsers;
 
-public interface CsvLineParser<Line> extends ContentParser<String[], Line> {
+import com.justinefactory.writing.domain.CsvContent;
+
+public interface CsvLineParser<RawContent> extends ContentParser<CsvContent, RawContent> {
 
 }
\ No newline at end of file
diff --git a/src/main/java/com/justinefactory/reading/parsers/IntegerPlainContentParser.java b/src/main/java/com/justinefactory/reading/parsers/IntegerPlainContentParser.java
index b4cd0bc..0260e7f 100644
--- a/src/main/java/com/justinefactory/reading/parsers/IntegerPlainContentParser.java
+++ b/src/main/java/com/justinefactory/reading/parsers/IntegerPlainContentParser.java
@@ -1,6 +1,8 @@
 package com.justinefactory.reading.parsers;
 
 import com.justinefactory.reading.exceptions.ContentParsingException;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.PlainContent;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -11,7 +13,15 @@ public class IntegerPlainContentParser implements PlainContentParser<Integer> {
     private final static Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
     @Override
-    public Integer parseLine(String rawLine) throws ContentParsingException {
+    public Content<Integer> parse(PlainContent strings) throws ContentParsingException {
+        Content<Integer> content = new Content<>();
+        for (String item : strings.getContent()) {
+            content.addContent(parseLine(item));
+        }
+        return content;
+    }
+
+    private Integer parseLine(String rawLine) throws ContentParsingException {
         if (rawLine.isEmpty()) {
             logger.warn("Parsing file line to Integer - failed. Line: {} does not equal required number of columns (1).", rawLine);
             throw new ContentParsingException("Parsing file line to Integer - failed. The line " + rawLine + " does not equal required number of columns (1).");
diff --git a/src/main/java/com/justinefactory/reading/parsers/PlainContentParser.java b/src/main/java/com/justinefactory/reading/parsers/PlainContentParser.java
index 4ea4cdd..a43158c 100644
--- a/src/main/java/com/justinefactory/reading/parsers/PlainContentParser.java
+++ b/src/main/java/com/justinefactory/reading/parsers/PlainContentParser.java
@@ -1,5 +1,7 @@
 package com.justinefactory.reading.parsers;
 
-public interface PlainContentParser<Line> extends ContentParser<String, Line> {
+import com.justinefactory.writing.domain.PlainContent;
+
+public interface PlainContentParser<RawContent> extends ContentParser<PlainContent, RawContent> {
 
 }
diff --git a/src/main/java/com/justinefactory/reading/parsers/ThreeElementCsvParser.java b/src/main/java/com/justinefactory/reading/parsers/ThreeElementCsvParser.java
index 3f709dd..f8f96b4 100644
--- a/src/main/java/com/justinefactory/reading/parsers/ThreeElementCsvParser.java
+++ b/src/main/java/com/justinefactory/reading/parsers/ThreeElementCsvParser.java
@@ -2,18 +2,30 @@
 
 import com.justinefactory.domain.ThreeElemContent;
 import com.justinefactory.reading.exceptions.ContentParsingException;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.CsvContent;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.lang.invoke.MethodHandles;
 import java.util.Arrays;
+import java.util.List;
 
 public class ThreeElementCsvParser implements CsvLineParser<ThreeElemContent> {
 
     private final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
     @Override
-    public ThreeElemContent parseLine(String[] csvLine) throws ContentParsingException {
+    public Content<ThreeElemContent> parse(CsvContent strings) throws ContentParsingException {
+        Content<ThreeElemContent> content = new Content<>();
+        for(String[] item : strings.getContent()){
+            content.addContent(parseLine(item));
+        }
+        return content;
+    }
+
+
+    private ThreeElemContent parseLine(String[] csvLine) throws ContentParsingException {
         logger.debug("Parsing csvFile line to ThreeElemContent class.");
         if (csvLine.length != 3) {
             logger.warn("Parsing csvFile line to ThreeElemContent class - CSV line: {} does not equal required number of columns (3).", csvLine);
@@ -32,4 +44,6 @@ public ThreeElemContent parseLine(String[] csvLine) throws ContentParsingExcepti
         }
 
     }
+
+
 }
diff --git a/src/main/java/com/justinefactory/reading/readers/ContentReader.java b/src/main/java/com/justinefactory/reading/readers/ContentReader.java
index c8807f3..79ecddc 100644
--- a/src/main/java/com/justinefactory/reading/readers/ContentReader.java
+++ b/src/main/java/com/justinefactory/reading/readers/ContentReader.java
@@ -1,10 +1,10 @@
 package com.justinefactory.reading.readers;
 
 import com.justinefactory.reading.exceptions.ContentReadingException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 
-public interface ContentReader<RawContent> {
+public interface ContentReader<ContentType> {
 
-    ContentStorage<RawContent> readContent() throws ContentReadingException;
+    ContentType readContent() throws ContentReadingException;
 
 }
diff --git a/src/main/java/com/justinefactory/reading/readers/CsvContentReader.java b/src/main/java/com/justinefactory/reading/readers/CsvContentReader.java
index 6fd4c59..4d47efd 100644
--- a/src/main/java/com/justinefactory/reading/readers/CsvContentReader.java
+++ b/src/main/java/com/justinefactory/reading/readers/CsvContentReader.java
@@ -4,7 +4,7 @@
 import com.justinefactory.reading.exceptions.ContentReadingException;
 import com.justinefactory.reading.exceptions.ReadingContentFromFileException;
 import com.justinefactory.reading.exceptions.SourceFileIsEmptyException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.CsvContent;
 import com.opencsv.CSVReader;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -12,12 +12,10 @@
 import java.io.Reader;
 import java.lang.invoke.MethodHandles;
 import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
 
 import static com.justinefactory.util.FileNotEmptyAndExistChecker.checkIfFileExistsIsNotDirAndNotEmpty;
 
-class CsvContentReader implements ContentReader<String[]> {
+class CsvContentReader implements ContentReader<CsvContent> {
 
     private final PathInfo fileData;
     private final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
@@ -28,7 +26,7 @@ class CsvContentReader implements ContentReader<String[]> {
 
 
     @Override
-    public ContentStorage<String[]> readContent() throws ContentReadingException {
+    public CsvContent readContent() throws ContentReadingException {
         logger.debug("Reading data from file id {}", fileData.getId());
         if (!checkIfFileExistsIsNotDirAndNotEmpty(fileData.getPath())) {
             logger.warn("Reading data from file id {} failed. File does not exist or is empty.", fileData.getId());
@@ -38,7 +36,7 @@ public ContentStorage<String[]> readContent() throws ContentReadingException {
         try (Reader reader = Files.newBufferedReader(fileData.getPath());
              CSVReader csvReader = new CSVReader(reader)
         ) {
-            ContentStorage<String[]> rawContent = new ContentStorage<>(csvReader.readAll());
+            CsvContent rawContent = new CsvContent(csvReader.readAll());
             logger.debug("Reading data from file id {} - success.", fileData.getId());
             return rawContent;
         } catch (Throwable e) {
diff --git a/src/main/java/com/justinefactory/reading/readers/PlainContentReader.java b/src/main/java/com/justinefactory/reading/readers/PlainContentReader.java
index 61405bd..48e1e6f 100644
--- a/src/main/java/com/justinefactory/reading/readers/PlainContentReader.java
+++ b/src/main/java/com/justinefactory/reading/readers/PlainContentReader.java
@@ -4,7 +4,7 @@
 import com.justinefactory.reading.exceptions.ContentReadingException;
 import com.justinefactory.reading.exceptions.ReadingContentFromFileException;
 import com.justinefactory.reading.exceptions.SourceFileIsEmptyException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.PlainContent;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -13,7 +13,7 @@
 
 import static com.justinefactory.util.FileNotEmptyAndExistChecker.checkIfFileExistsIsNotDirAndNotEmpty;
 
-class PlainContentReader implements ContentReader<String> {
+class PlainContentReader implements ContentReader<PlainContent> {
 
     private final PathInfo fileData;
     private final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
@@ -25,14 +25,14 @@ class PlainContentReader implements ContentReader<String> {
 
 
     @Override
-    public ContentStorage<String> readContent() throws ContentReadingException {
+    public PlainContent readContent() throws ContentReadingException {
         logger.debug("Reading data from file id {}", fileData.getId());
         if (!checkIfFileExistsIsNotDirAndNotEmpty(fileData.getPath())) {
             logger.warn("Reading data from file id {} failed. File does not exist or is empty.", fileData.getId());
             throw new SourceFileIsEmptyException("Reading data from file id " + fileData.getId() + " - failed. File does not exist or is empty.");
         }
-        try{
-            ContentStorage<String> rawContent = new ContentStorage<>(Files.readAllLines(fileData.getPath()));
+        try {
+            PlainContent rawContent = new PlainContent(Files.readAllLines(fileData.getPath()));
             logger.debug("Reading data from file id {} - success.", fileData.getId());
             return rawContent;
         } catch (Throwable e) {
diff --git a/src/main/java/com/justinefactory/reading/service/ContentReadingService.java b/src/main/java/com/justinefactory/reading/service/ContentReadingService.java
index c2298ed..ff85fb2 100644
--- a/src/main/java/com/justinefactory/reading/service/ContentReadingService.java
+++ b/src/main/java/com/justinefactory/reading/service/ContentReadingService.java
@@ -3,7 +3,7 @@
 import com.justinefactory.reading.exceptions.ContentReadingException;
 import com.justinefactory.reading.parsers.ContentParser;
 import com.justinefactory.reading.readers.ContentReader;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -23,12 +23,9 @@ public ContentReadingService(ContentReader<RawContent> cr, ContentParser<RawCont
     }
 
 
-    public ContentStorage<OutContent> processContent() throws ContentReadingException {
-        ContentStorage<RawContent> rawContent = contentReader.readContent();
-        ContentStorage<OutContent> content = new ContentStorage<>();
-        for (int i = 0; i < rawContent.getContentSize(); i++) {
-            content.addContent(contentParser.parseLine(rawContent.getContent(i)));
-        }
+    public Content<OutContent> processContent() throws ContentReadingException {
+        RawContent rawContent = contentReader.readContent();
+        Content<OutContent> content = contentParser.parse(rawContent);
         logger.info("Reading service - finished processing successfully.");
         return content;
     }
diff --git a/src/main/java/com/justinefactory/sending/domain/ContentAndStatsStorage.java b/src/main/java/com/justinefactory/sending/domain/ContentAndStats.java
similarity index 53%
rename from src/main/java/com/justinefactory/sending/domain/ContentAndStatsStorage.java
rename to src/main/java/com/justinefactory/sending/domain/ContentAndStats.java
index 211decc..e5664ab 100644
--- a/src/main/java/com/justinefactory/sending/domain/ContentAndStatsStorage.java
+++ b/src/main/java/com/justinefactory/sending/domain/ContentAndStats.java
@@ -1,33 +1,35 @@
 package com.justinefactory.sending.domain;
 
 import com.justinefactory.stats.domain.Stats;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 
 import java.util.Objects;
 
-public class ContentAndStatsStorage<Content> {
+public class ContentAndStats<ContentType> {
 
-    private final ContentStorage<Content> content;
-    private final Stats<Content> stats;
 
-    public ContentAndStatsStorage(ContentStorage<Content> ct, Stats<Content> st) throws IllegalArgumentException {
+    private final Content<ContentType> content;
+    private final Stats<ContentType> stats;
+
+    public ContentAndStats(Content<ContentType> ct, Stats<ContentType> st) throws IllegalArgumentException {
         checkIfIsNullOrEmpty(ct, st);
         content = ct;
         stats = st;
     }
 
 
-    private void checkIfIsNullOrEmpty(ContentStorage<Content> content, Stats<Content> stats) throws IllegalArgumentException {
-        if (content == null || content.getAllContent() == null || content.getAllContent().isEmpty() || stats == null) {
+    private void checkIfIsNullOrEmpty(Content<ContentType> content, Stats<ContentType> stats) throws IllegalArgumentException {
+        if (content == null || content.getContent() == null || content.getContent().isEmpty() || stats == null) {
             throw new IllegalArgumentException("Trouble while writing content: " + content + " and stats: " + stats + " to ContentStorage. Content or stats are empty or null.");
         }
     }
 
-    public ContentStorage<Content> getContent() {
+
+    public Content<ContentType> getContent() {
         return content;
     }
 
-    public Stats<Content> getStats() {
+    public Stats<ContentType> getStats() {
         return stats;
     }
 
@@ -35,7 +37,7 @@ public Stats<Content> getStats() {
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
-        ContentAndStatsStorage<Content> that = (ContentAndStatsStorage<Content>) o;
+        ContentAndStats<ContentType> that = (ContentAndStats<ContentType>) o;
         return Objects.equals(content, that.content) &&
                 Objects.equals(stats, that.stats);
     }
diff --git a/src/main/java/com/justinefactory/sending/domain/IntegerAndStats.java b/src/main/java/com/justinefactory/sending/domain/IntegerAndStats.java
new file mode 100644
index 0000000..a54f5f5
--- /dev/null
+++ b/src/main/java/com/justinefactory/sending/domain/IntegerAndStats.java
@@ -0,0 +1,13 @@
+package com.justinefactory.sending.domain;
+
+import com.justinefactory.stats.domain.Stats;
+import com.justinefactory.writing.domain.Content;
+
+public class IntegerAndStats extends ContentAndStats<Integer> {
+
+
+    public IntegerAndStats(Content<Integer> ct, Stats<Integer> st) throws IllegalArgumentException {
+        super(ct, st);
+    }
+
+}
diff --git a/src/main/java/com/justinefactory/sending/domain/ThreeElementContentAndStats.java b/src/main/java/com/justinefactory/sending/domain/ThreeElementContentAndStats.java
new file mode 100644
index 0000000..b8dbba6
--- /dev/null
+++ b/src/main/java/com/justinefactory/sending/domain/ThreeElementContentAndStats.java
@@ -0,0 +1,12 @@
+package com.justinefactory.sending.domain;
+
+import com.justinefactory.domain.ThreeElemContent;
+import com.justinefactory.stats.domain.Stats;
+import com.justinefactory.writing.domain.Content;
+
+public class ThreeElementContentAndStats extends ContentAndStats<ThreeElemContent> {
+
+    public ThreeElementContentAndStats(Content<ThreeElemContent> ct, Stats<ThreeElemContent> st) throws IllegalArgumentException {
+        super(ct, st);
+    }
+}
diff --git a/src/main/java/com/justinefactory/sending/service/ContentSendingService.java b/src/main/java/com/justinefactory/sending/service/ContentSendingService.java
index d5ed720..8b7ec5b 100644
--- a/src/main/java/com/justinefactory/sending/service/ContentSendingService.java
+++ b/src/main/java/com/justinefactory/sending/service/ContentSendingService.java
@@ -2,27 +2,27 @@
 
 import com.justinefactory.reading.exceptions.ContentReadingException;
 import com.justinefactory.reading.service.ContentReadingService;
-import com.justinefactory.sending.domain.ContentAndStatsStorage;
+import com.justinefactory.sending.domain.ContentAndStats;
 import com.justinefactory.stats.calculators.StatsCalculator;
 import com.justinefactory.stats.domain.Stats;
 import com.justinefactory.stats.exceptions.StatsCalculatingException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import com.justinefactory.writing.exceptions.ContentWritingException;
-import com.justinefactory.writing.writers.ContentWritingService;
+import com.justinefactory.writing.service.ContentWritingService;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.lang.invoke.MethodHandles;
 
-public class ContentSendingService<RawContent, Content, ReadyToSendContent> {
+public class ContentSendingService<RawContent, ContentType, ReadyToSendContent> {
 
-    private final ContentReadingService<RawContent, Content> contentReadingService;
-    private final StatsCalculator<Content> statsCalculator;
-    private final ContentWritingService<ContentAndStatsStorage<Content>, ReadyToSendContent> contentWritingService;
+    private final ContentReadingService<RawContent, ContentType> contentReadingService;
+    private final StatsCalculator<ContentType> statsCalculator;
+    private final ContentWritingService<ContentAndStats<ContentType>, ReadyToSendContent> contentWritingService;
     private static final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
 
-    public ContentSendingService(ContentReadingService<RawContent, Content> crs, StatsCalculator<Content> sc, ContentWritingService<ContentAndStatsStorage<Content>, ReadyToSendContent> cw) {
+    public ContentSendingService(ContentReadingService<RawContent, ContentType> crs, StatsCalculator<ContentType> sc, ContentWritingService<ContentAndStats<ContentType>, ReadyToSendContent> cw) {
         logger.info("Content sending service - initialization.");
         contentReadingService = crs;
         statsCalculator = sc;
@@ -31,9 +31,9 @@ public ContentSendingService(ContentReadingService<RawContent, Content> crs, Sta
 
 
     public void sendContent() throws ContentReadingException, StatsCalculatingException, ContentWritingException {
-        ContentStorage<Content> content = contentReadingService.processContent();
-        Stats<Content> stats = statsCalculator.calculateStats(content);
-        ContentAndStatsStorage<Content> contentAndStats = new ContentAndStatsStorage<>(content, stats);
+        Content<ContentType> content = contentReadingService.processContent();
+        Stats<ContentType> stats = statsCalculator.calculateStats(content);
+        ContentAndStats<ContentType> contentAndStats = new ContentAndStats<>(content, stats);
         contentWritingService.writeContent(contentAndStats);
         logger.info("Content sending service - success.");
     }
diff --git a/src/main/java/com/justinefactory/stats/calculators/IntegerContentStatsCalculator.java b/src/main/java/com/justinefactory/stats/calculators/IntegerContentStatsCalculator.java
index b65a0fb..3f60378 100644
--- a/src/main/java/com/justinefactory/stats/calculators/IntegerContentStatsCalculator.java
+++ b/src/main/java/com/justinefactory/stats/calculators/IntegerContentStatsCalculator.java
@@ -2,7 +2,7 @@
 
 import com.justinefactory.stats.domain.Stats;
 import com.justinefactory.stats.exceptions.StatsCalculatingException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -16,7 +16,7 @@ public class IntegerContentStatsCalculator implements StatsCalculator<Integer> {
     private final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
     @Override
-    public Stats<Integer> calculateStats(ContentStorage<Integer> content) throws StatsCalculatingException {
+    public Stats<Integer> calculateStats(Content<Integer> content) throws StatsCalculatingException {
         logger.debug("Calculating stats from Integer content.");
         if (content == null || content.isEmpty()) {
             logger.warn("Calculating stats from Integer content - failed. Collection {} was empty.", content);
@@ -31,17 +31,17 @@ public Stats<Integer> calculateStats(ContentStorage<Integer> content) throws Sta
     }
 
 
-    private Integer calculateCount(ContentStorage<Integer> content) {
+    private Integer calculateCount(Content<Integer> content) {
         return content.getContentSize();
     }
 
-    private Integer calculateUniqueCount(ContentStorage<Integer> content) {
-        Set<Integer> uniqueContent = new HashSet<>(content.getAllContent());
+    private Integer calculateUniqueCount(Content<Integer> content) {
+        Set<Integer> uniqueContent = new HashSet<>(content.getContent());
         return uniqueContent.size();
     }
 
-    private Integer calculateMax(ContentStorage<Integer> content) {
-        return Collections.max(content.getAllContent());
+    private Integer calculateMax(Content<Integer> content) {
+        return Collections.max(content.getContent());
     }
 
 
diff --git a/src/main/java/com/justinefactory/stats/calculators/StatsCalculator.java b/src/main/java/com/justinefactory/stats/calculators/StatsCalculator.java
index 0054b76..7ea52e6 100644
--- a/src/main/java/com/justinefactory/stats/calculators/StatsCalculator.java
+++ b/src/main/java/com/justinefactory/stats/calculators/StatsCalculator.java
@@ -2,10 +2,10 @@
 
 import com.justinefactory.stats.domain.Stats;
 import com.justinefactory.stats.exceptions.StatsCalculatingException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 
-public interface StatsCalculator<Content> {
+public interface StatsCalculator<ContentType> {
 
-    Stats<Content> calculateStats(ContentStorage<Content> content) throws StatsCalculatingException;
+    Stats<ContentType> calculateStats(Content<ContentType> content) throws StatsCalculatingException;
 
 }
diff --git a/src/main/java/com/justinefactory/stats/calculators/ThreeElementContentStatsCalculator.java b/src/main/java/com/justinefactory/stats/calculators/ThreeElementContentStatsCalculator.java
index 225650e..96e6914 100644
--- a/src/main/java/com/justinefactory/stats/calculators/ThreeElementContentStatsCalculator.java
+++ b/src/main/java/com/justinefactory/stats/calculators/ThreeElementContentStatsCalculator.java
@@ -3,7 +3,7 @@
 import com.justinefactory.domain.ThreeElemContent;
 import com.justinefactory.stats.domain.Stats;
 import com.justinefactory.stats.exceptions.StatsCalculatingException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -16,7 +16,7 @@ public class ThreeElementContentStatsCalculator implements StatsCalculator<Three
     private static final ThreeElementContentComparatorByRandomInt comparator = new ThreeElementContentComparatorByRandomInt();
 
     @Override
-    public Stats<ThreeElemContent> calculateStats(ContentStorage<ThreeElemContent> content) throws StatsCalculatingException {
+    public Stats<ThreeElemContent> calculateStats(Content<ThreeElemContent> content) throws StatsCalculatingException {
         logger.debug("Calculating stats from ThreeElementContent content.");
         if (content == null || content.isEmpty()) {
             logger.warn("Calculating stats from ThreeElementContent content - failed. Storage class {} is empty or does not exist.", content);
@@ -30,22 +30,22 @@ public Stats<ThreeElemContent> calculateStats(ContentStorage<ThreeElemContent> c
         return stats;
     }
 
-    private Integer calculateCount(ContentStorage<ThreeElemContent> content) {
+    private Integer calculateCount(Content<ThreeElemContent> content) {
         return content.getContentSize();
     }
 
 
-    private Integer calculateUniqueCount(ContentStorage<ThreeElemContent> content) {
+    private Integer calculateUniqueCount(Content<ThreeElemContent> content) {
         Set<StringIntContent> uniqueContent = new HashSet<>();
-        for (ThreeElemContent item : content.getAllContent()) {
+        for (ThreeElemContent item : content.getContent()) {
             uniqueContent.add(new StringIntContent(item));
         }
         return uniqueContent.size();
     }
 
 
-    private ThreeElemContent calculateMax(ContentStorage<ThreeElemContent> content) {
-        return Collections.max(content.getAllContent(), comparator);
+    private ThreeElemContent calculateMax(Content<ThreeElemContent> content) {
+        return Collections.max(content.getContent(), comparator);
     }
 
 
diff --git a/src/main/java/com/justinefactory/stats/domain/Stats.java b/src/main/java/com/justinefactory/stats/domain/Stats.java
index c6a485f..89f0da3 100644
--- a/src/main/java/com/justinefactory/stats/domain/Stats.java
+++ b/src/main/java/com/justinefactory/stats/domain/Stats.java
@@ -2,14 +2,14 @@
 
 import java.util.Objects;
 
-public class Stats<Content> {
+public class Stats<ContentType> {
 
     private final Integer count;
     private final Integer distinctCount;
-    private final Content max;
+    private final ContentType max;
 
 
-    public Stats(Integer count, Integer distinctCount, Content max) {
+    public Stats(Integer count, Integer distinctCount, ContentType max) {
         this.count = count;
         this.distinctCount = distinctCount;
         this.max = max;
@@ -19,7 +19,7 @@ public Integer getDistinctCount() {
         return distinctCount;
     }
 
-    public Content getMax() {
+    public ContentType getMax() {
         return max;
     }
 
diff --git a/src/main/java/com/justinefactory/writing/converters/ContentAndStatsToJsonConverter.java b/src/main/java/com/justinefactory/writing/converters/ContentAndStatsToJsonConverter.java
index b6ad50f..07d2c25 100644
--- a/src/main/java/com/justinefactory/writing/converters/ContentAndStatsToJsonConverter.java
+++ b/src/main/java/com/justinefactory/writing/converters/ContentAndStatsToJsonConverter.java
@@ -2,11 +2,11 @@
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
-import com.justinefactory.sending.domain.ContentAndStatsStorage;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.sending.domain.ContentAndStats;
+import com.justinefactory.writing.domain.JsonContent;
 import com.justinefactory.writing.exceptions.ContentConversion2ReadyToWriteException;
 
-public class ContentAndStatsToJsonConverter<Content> implements ContentConverter<ContentAndStatsStorage<Content>, ContentStorage<String>> {
+public class ContentAndStatsToJsonConverter<ContentType> implements ContentConverter<ContentAndStats<ContentType>, JsonContent> {
 
     private static final Gson gson = new GsonBuilder()
             .setPrettyPrinting()
@@ -14,12 +14,12 @@ public class ContentAndStatsToJsonConverter<Content> implements ContentConverter
 
 
     @Override
-    public ContentStorage<String> convertContent(ContentAndStatsStorage<Content> content) throws ContentConversion2ReadyToWriteException {
+    public JsonContent convertContent(ContentAndStats<ContentType> content) throws ContentConversion2ReadyToWriteException {
         if (content == null) {
             throw new ContentConversion2ReadyToWriteException("Converting content " + content + " into line - failed. Content is empty or does not exist.");
         }
         String json = gson.toJson(content);
-        return new ContentStorage<>(json);
+        return new JsonContent(json);
     }
 
 }
diff --git a/src/main/java/com/justinefactory/writing/converters/ContentConverter.java b/src/main/java/com/justinefactory/writing/converters/ContentConverter.java
index 40bf98b..4155c82 100644
--- a/src/main/java/com/justinefactory/writing/converters/ContentConverter.java
+++ b/src/main/java/com/justinefactory/writing/converters/ContentConverter.java
@@ -2,8 +2,8 @@
 
 import com.justinefactory.writing.exceptions.ContentConversion2ReadyToWriteException;
 
-public interface ContentConverter<Content, ReadyToWriteContent> {
+public interface ContentConverter<ContentType, ReadyToWriteContent> {
 
-    public ReadyToWriteContent convertContent(Content content) throws ContentConversion2ReadyToWriteException;
+    ReadyToWriteContent convertContent(ContentType content) throws ContentConversion2ReadyToWriteException;
 
 }
diff --git a/src/main/java/com/justinefactory/writing/converters/ContentToCsvLinesConverter.java b/src/main/java/com/justinefactory/writing/converters/ContentToCsvLinesConverter.java
deleted file mode 100644
index 43840fa..0000000
--- a/src/main/java/com/justinefactory/writing/converters/ContentToCsvLinesConverter.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package com.justinefactory.writing.converters;
-
-import com.justinefactory.writing.domain.ContentStorage;
-
-public interface ContentToCsvLinesConverter<Content> extends ContentConverter<Content, ContentStorage<String[]>> {
-
-}
diff --git a/src/main/java/com/justinefactory/writing/converters/IntegersToLinesConverter.java b/src/main/java/com/justinefactory/writing/converters/IntegersToLinesConverter.java
index 012e935..41420a2 100644
--- a/src/main/java/com/justinefactory/writing/converters/IntegersToLinesConverter.java
+++ b/src/main/java/com/justinefactory/writing/converters/IntegersToLinesConverter.java
@@ -1,21 +1,22 @@
 package com.justinefactory.writing.converters;
 
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.PlainContent;
 import com.justinefactory.writing.exceptions.ContentConversion2ReadyToWriteException;
 
-public class IntegersToLinesConverter implements ContentConverter<ContentStorage<Integer>, ContentStorage<String>> {
+public class IntegersToLinesConverter implements ContentConverter<Content<Integer>, PlainContent> {
 
     @Override
-    public ContentStorage<String> convertContent(ContentStorage<Integer> content) throws ContentConversion2ReadyToWriteException {
+    public PlainContent convertContent(Content<Integer> content) throws ContentConversion2ReadyToWriteException {
         checkIfContentNull(content);
-        ContentStorage<String> readyToWriteContent = new ContentStorage<>();
-        for (Integer item : content.getAllContent()) {
+        PlainContent readyToWriteContent = new PlainContent();
+        for (Integer item : content.getContent()) {
             readyToWriteContent.addContent(item.toString());
         }
         return readyToWriteContent;
     }
 
-    private void checkIfContentNull(ContentStorage<Integer> content) throws ContentConversion2ReadyToWriteException {
+    private void checkIfContentNull(Content<Integer> content) throws ContentConversion2ReadyToWriteException {
         if (content == null || content.isEmpty()) {
             throw new ContentConversion2ReadyToWriteException("Converting content " + content + " into csvFile line - failed. Content is empty or null.");
         }
diff --git a/src/main/java/com/justinefactory/writing/converters/ThreeElementContentToCsvLinesConverter.java b/src/main/java/com/justinefactory/writing/converters/ThreeElementContentToCsvLinesConverter.java
index 9f4abb8..f1bc65e 100644
--- a/src/main/java/com/justinefactory/writing/converters/ThreeElementContentToCsvLinesConverter.java
+++ b/src/main/java/com/justinefactory/writing/converters/ThreeElementContentToCsvLinesConverter.java
@@ -1,30 +1,31 @@
 package com.justinefactory.writing.converters;
 
 import com.justinefactory.domain.ThreeElemContent;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.CsvContent;
 import com.justinefactory.writing.exceptions.ContentConversion2ReadyToWriteException;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.lang.invoke.MethodHandles;
 
-public class ThreeElementContentToCsvLinesConverter implements ContentToCsvLinesConverter<ContentStorage<ThreeElemContent>> {
+public class ThreeElementContentToCsvLinesConverter implements ContentConverter<Content<ThreeElemContent>, CsvContent> {
 
     private final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
     @Override
-    public ContentStorage<String[]> convertContent(ContentStorage<ThreeElemContent> content) throws ContentConversion2ReadyToWriteException {
+    public CsvContent convertContent(Content<ThreeElemContent> content) throws ContentConversion2ReadyToWriteException {
         checkIfContentEmpty(content);
-        ContentStorage<String[]> readyToWriteContent = new ContentStorage<>();
-        for (ThreeElemContent item : content.getAllContent()) {
+        CsvContent readyToWriteContent = new CsvContent();
+        for (ThreeElemContent item : content.getContent()) {
             readyToWriteContent.addContent(new String[]{item.getTimeStamp().toString(), item.getRandomInt().toString(), item.getRandomString()});
             logger.debug("Converting ThreeElemContent object {} into csvFile lines - success.", content);
         }
         return readyToWriteContent;
     }
 
-    private void checkIfContentEmpty(ContentStorage<ThreeElemContent> content) throws ContentConversion2ReadyToWriteException {
-        if (content.getAllContent().isEmpty()) {
+    private void checkIfContentEmpty(Content<ThreeElemContent> content) throws ContentConversion2ReadyToWriteException {
+        if (content.isEmpty()) {
             throw new ContentConversion2ReadyToWriteException("Converting content " + content + " into csvFile lines - failed. Content was empty.");
         }
     }
diff --git a/src/main/java/com/justinefactory/writing/domain/ContentStorage.java b/src/main/java/com/justinefactory/writing/domain/Content.java
similarity index 68%
rename from src/main/java/com/justinefactory/writing/domain/ContentStorage.java
rename to src/main/java/com/justinefactory/writing/domain/Content.java
index 8cdfe79..9818828 100644
--- a/src/main/java/com/justinefactory/writing/domain/ContentStorage.java
+++ b/src/main/java/com/justinefactory/writing/domain/Content.java
@@ -5,37 +5,37 @@
 import java.util.List;
 import java.util.Objects;
 
-public class ContentStorage<Content> {
+public class Content<ContentType> {
 
-    private final List<Content> content;
+    private final List<ContentType> content;
 
-    public ContentStorage() {
+    public Content() {
         content = new ArrayList<>();
     }
 
 
-    public ContentStorage(List<Content> rc) throws IllegalArgumentException {
+    public Content(List<ContentType> rc) throws IllegalArgumentException {
         if (rc == null)
             throw new IllegalArgumentException("Trouble while writing content " + rc + " into Storage. Content is null.");
-        for (Content item : rc) {
+        for (ContentType item : rc) {
             checkIfContentNull(item);
         }
         content = rc;
     }
 
-    public ContentStorage(Content rc) throws IllegalArgumentException {
+    public Content(ContentType rc) throws IllegalArgumentException {
         checkIfContentNull(rc);
         content = new ArrayList<>();
         content.add(rc);
     }
 
-    private void checkIfContentNull(Content content) throws IllegalArgumentException {
+    private void checkIfContentNull(ContentType content) throws IllegalArgumentException {
         if (content == null) {
             throw new IllegalArgumentException("Trouble while writing content " + content + " into Storage. Content is null.");
         }
     }
 
-    public Content getContent(int i) {
+    public ContentType getContent(int i) {
         return content.get(i);
     }
 
@@ -43,12 +43,13 @@ public int getContentSize() {
         return content.size();
     }
 
-    public void addContent(Content content) throws IllegalArgumentException {
+    public void addContent(ContentType content) throws IllegalArgumentException {
         checkIfContentNull(content);
         this.content.add(content);
     }
 
-    public Collection<Content> getAllContent() {
+
+    public Collection<ContentType> getContent() {
         return content;
     }
 
@@ -61,7 +62,7 @@ public boolean isEmpty() {
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
-        ContentStorage<Content> that = (ContentStorage<Content>) o;
+        Content<ContentType> that = (Content<ContentType>) o;
         if (content.size() != that.content.size()) return false;
         return content.equals(that.content);
     }
diff --git a/src/main/java/com/justinefactory/writing/domain/CsvContent.java b/src/main/java/com/justinefactory/writing/domain/CsvContent.java
new file mode 100644
index 0000000..218cfe2
--- /dev/null
+++ b/src/main/java/com/justinefactory/writing/domain/CsvContent.java
@@ -0,0 +1,71 @@
+package com.justinefactory.writing.domain;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+
+public class CsvContent {
+
+    private final List<String[]> content;
+
+    public CsvContent() {
+        content = new ArrayList<>();
+    }
+
+    public CsvContent(String[] rc) throws IllegalArgumentException {
+        checkIfContentNull(rc);
+        content = new ArrayList<>();
+        content.add(rc);
+    }
+
+    public CsvContent(List<String[]> list) {
+        for (String[] item : list) {
+            checkIfContentNull(item);
+        }
+        content = new ArrayList<>();
+        content.addAll(list);
+    }
+
+    public String[] getContent(int i) {
+        return content.get(i);
+    }
+
+
+    public void addContent(String[] content) throws IllegalArgumentException {
+        checkIfContentNull(content);
+        this.content.add(content);
+    }
+
+    private void checkIfContentNull(String[] content) throws IllegalArgumentException {
+        if (content == null) {
+            throw new IllegalArgumentException("Trouble while writing content " + content + " into Storage. Content is null.");
+        }
+    }
+
+    public Collection<String[]> getContent() {
+        return content;
+    }
+
+    public boolean isEmpty() {
+        return content.size() == 0;
+    }
+
+    public Integer size() {
+        return content.size();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        CsvContent that = (CsvContent) o;
+        if (content.size() != that.content.size()) return false;
+        return content.equals(that.content);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(content);
+    }
+}
diff --git a/src/main/java/com/justinefactory/writing/domain/JsonContent.java b/src/main/java/com/justinefactory/writing/domain/JsonContent.java
new file mode 100644
index 0000000..1eac68d
--- /dev/null
+++ b/src/main/java/com/justinefactory/writing/domain/JsonContent.java
@@ -0,0 +1,22 @@
+package com.justinefactory.writing.domain;
+
+public class JsonContent {
+
+    private final String json;
+
+    public JsonContent(String json) {
+        ensureJsonNotEmptyAndNotNull(json);
+        this.json = json;
+    }
+
+    private void ensureJsonNotEmptyAndNotNull(String json) throws IllegalArgumentException {
+        if (json == null || json.isEmpty()) {
+            throw new IllegalArgumentException("Trouble while writing json: " + json + ". The argument cannot be empty or null.");
+        }
+    }
+
+    public String getContent() {
+        return json;
+    }
+
+}
diff --git a/src/main/java/com/justinefactory/writing/domain/PlainContent.java b/src/main/java/com/justinefactory/writing/domain/PlainContent.java
new file mode 100644
index 0000000..0bdd01a
--- /dev/null
+++ b/src/main/java/com/justinefactory/writing/domain/PlainContent.java
@@ -0,0 +1,65 @@
+package com.justinefactory.writing.domain;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+
+public class PlainContent {
+
+    private final List<String> content;
+
+    public PlainContent() {
+        content = new ArrayList<>();
+    }
+
+    public PlainContent(List<String> rc) throws IllegalArgumentException {
+        if (rc == null)
+            throw new IllegalArgumentException("Trouble while writing content " + rc + " into Storage. Content is null.");
+        for (String item : rc) {
+            checkIfContentNull(item);
+        }
+        content = rc;
+    }
+
+
+    public String getContent(int i) {
+        return content.get(i);
+    }
+
+
+    public void addContent(String content) throws IllegalArgumentException {
+        checkIfContentNull(content);
+        this.content.add(content);
+    }
+
+    private void checkIfContentNull(String content) throws IllegalArgumentException {
+        if (content == null) {
+            throw new IllegalArgumentException("Trouble while writing content " + content + " into Storage. Content is null.");
+        }
+    }
+
+    public Collection<String> getContent() {
+        return content;
+    }
+
+    public boolean isEmpty() {
+        return content.size() == 0;
+    }
+
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PlainContent that = (PlainContent) o;
+        if (content.size() != that.content.size()) return false;
+        return content.equals(that.content);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(content);
+    }
+
+}
diff --git a/src/main/java/com/justinefactory/writing/generators/ContentGenerator.java b/src/main/java/com/justinefactory/writing/generators/ContentGenerator.java
index 744778b..5912fd0 100644
--- a/src/main/java/com/justinefactory/writing/generators/ContentGenerator.java
+++ b/src/main/java/com/justinefactory/writing/generators/ContentGenerator.java
@@ -1,10 +1,10 @@
 package com.justinefactory.writing.generators;
 
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import com.justinefactory.writing.exceptions.ContentGeneratingException;
 
-public interface ContentGenerator<Content> {
+public interface ContentGenerator<ContentType> {
 
-    ContentStorage<Content> generateContent(int nLines) throws ContentGeneratingException;
+    Content<ContentType> generateContent(int nLines) throws ContentGeneratingException;
 
 }
diff --git a/src/main/java/com/justinefactory/writing/generators/RandomIntegerGenerator.java b/src/main/java/com/justinefactory/writing/generators/RandomIntegerGenerator.java
index db7ab81..332f228 100644
--- a/src/main/java/com/justinefactory/writing/generators/RandomIntegerGenerator.java
+++ b/src/main/java/com/justinefactory/writing/generators/RandomIntegerGenerator.java
@@ -1,6 +1,6 @@
 package com.justinefactory.writing.generators;
 
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -17,9 +17,9 @@ public RandomIntegerGenerator(Random newNumber) {
     }
 
     @Override
-    public ContentStorage<Integer> generateContent(int nLines) {
+    public Content<Integer> generateContent(int nLines) {
         logger.debug("Generating random Integers.");
-        ContentStorage<Integer> randomContent = new ContentStorage<>();
+        Content<Integer> randomContent = new Content<>();
         for (int i = 0; i < nLines; i++) {
             randomContent.addContent(newNumber.nextInt());
         }
diff --git a/src/main/java/com/justinefactory/writing/generators/RandomStringGeneratorFromFile.java b/src/main/java/com/justinefactory/writing/generators/RandomStringGeneratorFromFile.java
index 4346670..26aac0c 100644
--- a/src/main/java/com/justinefactory/writing/generators/RandomStringGeneratorFromFile.java
+++ b/src/main/java/com/justinefactory/writing/generators/RandomStringGeneratorFromFile.java
@@ -1,7 +1,7 @@
 package com.justinefactory.writing.generators;
 
 import com.justinefactory.domain.PathInfo;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import com.justinefactory.writing.domain.TwoElemContent;
 import com.justinefactory.writing.exceptions.ContentGeneratingException;
 import com.justinefactory.writing.exceptions.ContentInitializationException;
@@ -32,9 +32,9 @@ public RandomStringGeneratorFromFile(Random newNumber, PathInfo fileWithRandomSt
 
 
     @Override
-    public ContentStorage<TwoElemContent> generateContent(int nLines) {
+    public Content<TwoElemContent> generateContent(int nLines) {
         logger.debug("Generating random strings from file.");
-        ContentStorage<TwoElemContent> randomContent = new ContentStorage<>();
+        Content<TwoElemContent> randomContent = new Content<>();
 
         for (int i = 0; i < nLines; i++) {
 
diff --git a/src/main/java/com/justinefactory/writing/generators/ThreeElementContentGenerator.java b/src/main/java/com/justinefactory/writing/generators/ThreeElementContentGenerator.java
index 85c32af..72c31b8 100644
--- a/src/main/java/com/justinefactory/writing/generators/ThreeElementContentGenerator.java
+++ b/src/main/java/com/justinefactory/writing/generators/ThreeElementContentGenerator.java
@@ -1,7 +1,7 @@
 package com.justinefactory.writing.generators;
 
 import com.justinefactory.domain.ThreeElemContent;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import com.justinefactory.writing.domain.TwoElemContent;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -22,11 +22,11 @@ public ThreeElementContentGenerator(RandomIntegerGenerator randomIntegerGenerato
 
 
     @Override
-    public ContentStorage<ThreeElemContent> generateContent(int nLines) {
+    public Content<ThreeElemContent> generateContent(int nLines) {
         logger.debug("Generating {} items of 3 element content.", nLines);
-        ContentStorage<Integer> randomInt = intGenerator.generateContent(nLines);
-        ContentStorage<TwoElemContent> randomStrTStamp = strAndTStampGenerator.generateContent(nLines);
-        ContentStorage<ThreeElemContent> randomContent = new ContentStorage<>();
+        Content<Integer> randomInt = intGenerator.generateContent(nLines);
+        Content<TwoElemContent> randomStrTStamp = strAndTStampGenerator.generateContent(nLines);
+        Content<ThreeElemContent> randomContent = new Content<>();
 
         for (int i = 0; i < nLines; i++) {
             ThreeElemContent threeContent = createThreeElemContentObject(randomInt.getContent(i), randomStrTStamp.getContent(i));
diff --git a/src/main/java/com/justinefactory/writing/service/ContentGeneratingAndWritingService.java b/src/main/java/com/justinefactory/writing/service/ContentGeneratingAndWritingService.java
index 5b6382c..c4c4f87 100644
--- a/src/main/java/com/justinefactory/writing/service/ContentGeneratingAndWritingService.java
+++ b/src/main/java/com/justinefactory/writing/service/ContentGeneratingAndWritingService.java
@@ -1,24 +1,23 @@
 package com.justinefactory.writing.service;
 
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import com.justinefactory.writing.exceptions.ContentGeneratingException;
 import com.justinefactory.writing.exceptions.ContentWritingException;
 import com.justinefactory.writing.generators.ContentGenerator;
-import com.justinefactory.writing.writers.ContentWritingService;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.lang.invoke.MethodHandles;
 
 
-class ContentGeneratingAndWritingService<Content, FormattedContent> {
+class ContentGeneratingAndWritingService<ContentType, FormattedContent> {
 
-    private final ContentGenerator<Content> contentGenerator;
-    private final ContentWritingService<ContentStorage<Content>, ContentStorage<FormattedContent>> contentWritingService;
+    private final ContentGenerator<ContentType> contentGenerator;
+    private final ContentWritingService<Content<ContentType>, Content<FormattedContent>> contentWritingService;
     private static final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
 
-    public ContentGeneratingAndWritingService(ContentWritingService<ContentStorage<Content>, ContentStorage<FormattedContent>> fw, ContentGenerator<Content> rig) {
+    public ContentGeneratingAndWritingService(ContentWritingService<Content<ContentType>, Content<FormattedContent>> fw, ContentGenerator<ContentType> rig) {
         logger.info("Writing service - initialization.");
         this.contentWritingService = fw;
         this.contentGenerator = rig;
@@ -26,7 +25,7 @@ public ContentGeneratingAndWritingService(ContentWritingService<ContentStorage<C
 
 
     public void processContent(int nLines) throws ContentWritingException, ContentGeneratingException {
-        ContentStorage<Content> content = contentGenerator.generateContent(nLines);
+        Content<ContentType> content = contentGenerator.generateContent(nLines);
         contentWritingService.writeContent(content);
         logger.info("Writing service - finished processing successfully.");
     }
diff --git a/src/main/java/com/justinefactory/writing/writers/ContentWritingService.java b/src/main/java/com/justinefactory/writing/service/ContentWritingService.java
similarity index 80%
rename from src/main/java/com/justinefactory/writing/writers/ContentWritingService.java
rename to src/main/java/com/justinefactory/writing/service/ContentWritingService.java
index 4821611..6c1c173 100644
--- a/src/main/java/com/justinefactory/writing/writers/ContentWritingService.java
+++ b/src/main/java/com/justinefactory/writing/service/ContentWritingService.java
@@ -1,26 +1,27 @@
-package com.justinefactory.writing.writers;
+package com.justinefactory.writing.service;
 
 import com.justinefactory.domain.WritingInfo;
 import com.justinefactory.writing.converters.ContentConverter;
 import com.justinefactory.writing.exceptions.ContentWritingException;
 import com.justinefactory.writing.util.CheckerIfContentAlreadyWritten;
 import com.justinefactory.writing.util.StorageContainerCreator;
+import com.justinefactory.writing.writers.ContentWriter;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.lang.invoke.MethodHandles;
 
-public class ContentWritingService<Content, ReadyToWriteContent> {
+public class ContentWritingService<ContentType, ReadyToWriteContent> {
 
     private final WritingInfo writingInfo;
     private final CheckerIfContentAlreadyWritten<WritingInfo> checkerIfContentWritten;
     private final StorageContainerCreator<WritingInfo> storageContainerCreator;
-    private final ContentConverter<Content, ReadyToWriteContent> converter;
+    private final ContentConverter<ContentType, ReadyToWriteContent> converter;
     private final ContentWriter<ReadyToWriteContent, WritingInfo> writer;
     private final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
 
-    ContentWritingService(WritingInfo fd, CheckerIfContentAlreadyWritten<WritingInfo> cicaw, StorageContainerCreator<WritingInfo> scc, ContentConverter<Content, ReadyToWriteContent> cr, ContentWriter<ReadyToWriteContent, WritingInfo> wt) {
+    ContentWritingService(WritingInfo fd, CheckerIfContentAlreadyWritten<WritingInfo> cicaw, StorageContainerCreator<WritingInfo> scc, ContentConverter<ContentType, ReadyToWriteContent> cr, ContentWriter<ReadyToWriteContent, WritingInfo> wt) {
         writingInfo = fd;
         checkerIfContentWritten = cicaw;
         storageContainerCreator = scc;
@@ -28,7 +29,7 @@ public class ContentWritingService<Content, ReadyToWriteContent> {
         writer = wt;
     }
 
-    public void writeContent(Content content) throws ContentWritingException {
+    public void writeContent(ContentType content) throws ContentWritingException {
         logger.info("Writing content to path {} - initialization.", writingInfo.getURI());
         if (content == null) {
             throw new ContentWritingException("Problem while Writing content to path " + writingInfo.getURI() + " content " + content + " is empty or does not exist.");
@@ -39,7 +40,6 @@ public void writeContent(Content content) throws ContentWritingException {
         ReadyToWriteContent readyToWriteContent = converter.convertContent(content);
         logger.debug("Writing content to path {} - content has been converted to lines.", writingInfo.getURI());
         writer.writeContent(readyToWriteContent, writingInfo);
-        logger.debug("Writing content to path {} - lines have been written and appended into path.", writingInfo.getURI());
         logger.info("Writing content to path {} - success.", writingInfo.getURI());
     }
 
diff --git a/src/main/java/com/justinefactory/writing/writers/ContentWriter.java b/src/main/java/com/justinefactory/writing/writers/ContentWriter.java
index 68d738d..171f1a4 100644
--- a/src/main/java/com/justinefactory/writing/writers/ContentWriter.java
+++ b/src/main/java/com/justinefactory/writing/writers/ContentWriter.java
@@ -3,8 +3,8 @@
 import com.justinefactory.domain.WritingInfo;
 import com.justinefactory.writing.exceptions.ContentWritingException;
 
-public interface ContentWriter<Content, WritingInfo> {
+public interface ContentWriter<ContentType, WritingInfo> {
 
-    void writeContent(Content content, WritingInfo info) throws ContentWritingException;
+    void writeContent(ContentType content, WritingInfo info) throws ContentWritingException;
 
 }
diff --git a/src/main/java/com/justinefactory/writing/writers/server/writers/JsonAwsWriter.java b/src/main/java/com/justinefactory/writing/writers/tocloud/JsonAwsWriter.java
similarity index 68%
rename from src/main/java/com/justinefactory/writing/writers/server/writers/JsonAwsWriter.java
rename to src/main/java/com/justinefactory/writing/writers/tocloud/JsonAwsWriter.java
index e0ae649..c68b970 100644
--- a/src/main/java/com/justinefactory/writing/writers/server/writers/JsonAwsWriter.java
+++ b/src/main/java/com/justinefactory/writing/writers/tocloud/JsonAwsWriter.java
@@ -1,14 +1,14 @@
-package com.justinefactory.writing.writers.server.writers;
+package com.justinefactory.writing.writers.tocloud;
 
 import com.amazonaws.services.s3.AmazonS3;
 import com.justinefactory.domain.AwsInfo;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.JsonContent;
 import com.justinefactory.writing.exceptions.AwsContentWritingException;
 import com.justinefactory.writing.writers.ContentWriter;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-public class JsonAwsWriter implements ContentWriter<ContentStorage<String>, AwsInfo> {
+public class JsonAwsWriter implements ContentWriter<JsonContent, AwsInfo> {
 
     private final AmazonS3 client;
     private final Logger logger = LogManager.getLogger(this.getClass());
@@ -18,8 +18,8 @@ public JsonAwsWriter(AmazonS3 awsClient) {
     }
 
     @Override
-    public void writeContent(ContentStorage<String> json, AwsInfo awsInfo) throws AwsContentWritingException {
-        String jsonToSend = String.join(System.lineSeparator(), json.getAllContent());
+    public void writeContent(JsonContent jsonContentStorage, AwsInfo awsInfo) throws AwsContentWritingException {
+        String jsonToSend = jsonContentStorage.getContent();
         try {
             client.putObject(awsInfo.getBucketName(), awsInfo.getKeyName(), jsonToSend);
         } catch (Throwable e) {
diff --git a/src/main/java/com/justinefactory/writing/writers/file/writers/CsvFileWriter.java b/src/main/java/com/justinefactory/writing/writers/tofile/CsvFileWriter.java
similarity index 72%
rename from src/main/java/com/justinefactory/writing/writers/file/writers/CsvFileWriter.java
rename to src/main/java/com/justinefactory/writing/writers/tofile/CsvFileWriter.java
index f58e186..cd5de11 100644
--- a/src/main/java/com/justinefactory/writing/writers/file/writers/CsvFileWriter.java
+++ b/src/main/java/com/justinefactory/writing/writers/tofile/CsvFileWriter.java
@@ -1,7 +1,7 @@
-package com.justinefactory.writing.writers.file.writers;
+package com.justinefactory.writing.writers.tofile;
 
 import com.justinefactory.domain.PathInfo;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.CsvContent;
 import com.justinefactory.writing.exceptions.ContentWritingException;
 import com.justinefactory.writing.writers.ContentWriter;
 import com.opencsv.CSVWriter;
@@ -13,17 +13,17 @@
 import java.lang.invoke.MethodHandles;
 import java.nio.file.Files;
 
-public class CsvFileWriter implements ContentWriter<ContentStorage<String[]>, PathInfo> {
+public class CsvFileWriter implements ContentWriter<CsvContent, PathInfo> {
 
     private final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
 
     @Override
-    public void writeContent(ContentStorage<String[]> content, PathInfo fileData) throws ContentWritingException {
+    public void writeContent(CsvContent content, PathInfo fileData) throws ContentWritingException {
         try (BufferedWriter writer = Files.newBufferedWriter(fileData.getPath());
              CSVWriter csvWriter = new CSVWriter(writer)
         ) {
-            for (String[] item : content.getAllContent()) {
+            for (String[] item : content.getContent()) {
                 csvWriter.writeNext(item);
             }
 
diff --git a/src/main/java/com/justinefactory/writing/writers/tofile/JsonFileWriter.java b/src/main/java/com/justinefactory/writing/writers/tofile/JsonFileWriter.java
new file mode 100644
index 0000000..fec66d2
--- /dev/null
+++ b/src/main/java/com/justinefactory/writing/writers/tofile/JsonFileWriter.java
@@ -0,0 +1,28 @@
+package com.justinefactory.writing.writers.tofile;
+
+import com.justinefactory.domain.PathInfo;
+import com.justinefactory.writing.domain.JsonContent;
+import com.justinefactory.writing.exceptions.ContentWritingException;
+import com.justinefactory.writing.writers.ContentWriter;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.nio.file.Files;
+
+public class JsonFileWriter implements ContentWriter<JsonContent, PathInfo> {
+
+    private final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
+
+    @Override
+    public void writeContent(JsonContent jsonContent, PathInfo pathInfo) throws ContentWritingException {
+        try (BufferedWriter writer = Files.newBufferedWriter(pathInfo.getPath())) {
+            writer.write(jsonContent.getContent());
+        } catch (IOException e) {
+            logger.warn("Problem while writing to file. Message: {}. Writing aborted.", e.getMessage());
+            throw new ContentWritingException(e, "Problem while writing to file. Writing aborted.");
+        }
+    }
+}
diff --git a/src/main/java/com/justinefactory/writing/writers/file/writers/PlainFileWriter.java b/src/main/java/com/justinefactory/writing/writers/tofile/PlainFileWriter.java
similarity index 71%
rename from src/main/java/com/justinefactory/writing/writers/file/writers/PlainFileWriter.java
rename to src/main/java/com/justinefactory/writing/writers/tofile/PlainFileWriter.java
index 1f7c5b7..53acdad 100644
--- a/src/main/java/com/justinefactory/writing/writers/file/writers/PlainFileWriter.java
+++ b/src/main/java/com/justinefactory/writing/writers/tofile/PlainFileWriter.java
@@ -1,7 +1,7 @@
-package com.justinefactory.writing.writers.file.writers;
+package com.justinefactory.writing.writers.tofile;
 
 import com.justinefactory.domain.PathInfo;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.PlainContent;
 import com.justinefactory.writing.exceptions.ContentWritingException;
 import com.justinefactory.writing.writers.ContentWriter;
 import org.apache.logging.log4j.LogManager;
@@ -12,14 +12,14 @@
 import java.lang.invoke.MethodHandles;
 import java.nio.file.Files;
 
-public class PlainFileWriter implements ContentWriter<ContentStorage<String>, PathInfo> {
+public class PlainFileWriter implements ContentWriter<PlainContent, PathInfo> {
 
     private final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass());
 
     @Override
-    public void writeContent(ContentStorage<String> content, PathInfo fileData) throws ContentWritingException {
+    public void writeContent(PlainContent content, PathInfo fileData) throws ContentWritingException {
         try (BufferedWriter writer = Files.newBufferedWriter(fileData.getPath())) {
-            for (String item : content.getAllContent()) {
+            for (String item : content.getContent()) {
                 writer.write(item);
                 writer.newLine();
             }
diff --git a/src/test/java/com/justinefactory/cloud/communication/transfer/S3CloudObjectContentGetterTest.java b/src/test/java/com/justinefactory/cloud/communication/transfer/S3CloudObjectContentGetterTest.java
new file mode 100644
index 0000000..4bf3dbe
--- /dev/null
+++ b/src/test/java/com/justinefactory/cloud/communication/transfer/S3CloudObjectContentGetterTest.java
@@ -0,0 +1,57 @@
+package com.justinefactory.cloud.communication.transfer;
+
+import com.amazonaws.AmazonServiceException;
+import com.amazonaws.services.s3.AmazonS3;
+import com.justinefactory.domain.AwsInfo;
+import com.justinefactory.reading.exceptions.AwsContentReadingException;
+import com.justinefactory.sending.exceptions.AwsSecurityCredentialsException;
+import com.justinefactory.writing.domain.JsonContent;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+
+import static com.justinefactory.testutil.AwsClientCreatorBeforeEach.createAwsClient;
+import static org.junit.jupiter.api.Assertions.*;
+
+class S3CloudObjectContentGetterTest {
+
+    private static AmazonS3 awsClient;
+    private static AwsInfo info;
+
+    @BeforeEach
+    public void createAwsClientAndAwsInfo() throws AwsSecurityCredentialsException {
+        awsClient = createAwsClient();
+        info = new AwsInfo("com.justyna.lisok.factory.content-bucket", "three-element-content-test.json");
+    }
+
+
+    @Test
+    public void getObjectWhenMeetingConditions() throws IOException, AwsContentReadingException {
+        //given
+        JsonExtractorFromS3ObjectInputStream extractor = new JsonExtractorFromS3ObjectInputStream();
+        S3CloudObjectContentGetter<JsonContent> getter = new S3CloudObjectContentGetter<>(awsClient, extractor);
+
+        //when
+        JsonContent storage = getter.getObjectContent(info);
+
+        //then
+        assertNotNull(storage.getContent());
+        assertFalse(storage.getContent().isEmpty());
+    }
+
+
+    @Test
+    public void getObjectWhenNoSuchFile() {
+        //given
+        JsonExtractorFromS3ObjectInputStream extractor = new JsonExtractorFromS3ObjectInputStream();
+        S3CloudObjectContentGetter<JsonContent> getter = new S3CloudObjectContentGetter<>(awsClient, extractor);
+
+        //when
+        AwsInfo infoNoSuchFile = new AwsInfo("com.justyna.lisok.factory.content-bucket", "three-element-content-test-no-such-file.json");
+
+        //then
+        assertThrows(AmazonServiceException.class, () -> getter.getObjectContent(infoNoSuchFile));
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/justinefactory/deserialization/deserializers/JsonContentDeserializerTest.java b/src/test/java/com/justinefactory/deserialization/deserializers/JsonContentDeserializerTest.java
new file mode 100644
index 0000000..9e6029c
--- /dev/null
+++ b/src/test/java/com/justinefactory/deserialization/deserializers/JsonContentDeserializerTest.java
@@ -0,0 +1,62 @@
+package com.justinefactory.deserialization.deserializers;
+
+import com.justinefactory.domain.ThreeElemContent;
+import com.justinefactory.reading.exceptions.ContentDeserializationException;
+import com.justinefactory.sending.domain.ContentAndStats;
+import com.justinefactory.sending.domain.IntegerAndStats;
+import com.justinefactory.sending.domain.ThreeElementContentAndStats;
+import com.justinefactory.stats.domain.Stats;
+import com.justinefactory.writing.converters.ContentAndStatsToJsonConverter;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.JsonContent;
+import com.justinefactory.writing.exceptions.ContentConversion2ReadyToWriteException;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class JsonContentDeserializerTest {
+
+
+    @Test
+    void deserializeToThreeElemContentAndStats() throws ContentDeserializationException, ContentConversion2ReadyToWriteException {
+        // given
+        Content<ThreeElemContent> content = new Content<>(new ThreeElemContent(1590147349818750700L, -840762737, "ChristopherRobin"));
+        Stats<ThreeElemContent> stats = new Stats<>(1, 1, content.getContent(0));
+        ThreeElementContentAndStats expectedStorage = new ThreeElementContentAndStats(content, stats);
+        JsonContent jsonContent = serializeContentAndStats(expectedStorage);
+        JsonDeserializer<ThreeElementContentAndStats> deserializer = new JsonDeserializer<>();
+        Class<ThreeElementContentAndStats> classType = ThreeElementContentAndStats.class;
+
+        //when
+        ThreeElementContentAndStats actualStorage = deserializer.deserialize(jsonContent, classType);
+
+        //then
+        assertEquals(expectedStorage, actualStorage);
+
+    }
+
+    @Test
+    void deserializeToIntegerContentAndStats() throws ContentDeserializationException, ContentConversion2ReadyToWriteException {
+        // given
+        Content<Integer> content = new Content<>(8);
+        Stats<Integer> stats = new Stats<>(1, 1, 8);
+        IntegerAndStats expectedStorage = new IntegerAndStats(content, stats);
+        JsonContent jsonContent = serializeContentAndStats(expectedStorage);
+        JsonDeserializer<IntegerAndStats> deserializer = new JsonDeserializer<>();
+        Class<IntegerAndStats> classType = IntegerAndStats.class;
+
+        //when
+        IntegerAndStats actualStorage = deserializer.deserialize(jsonContent, classType);
+
+        //then
+        assertEquals(expectedStorage, actualStorage);
+
+    }
+
+
+    private static <ContentType> JsonContent serializeContentAndStats(ContentAndStats<ContentType> storage) throws ContentConversion2ReadyToWriteException {
+        ContentAndStatsToJsonConverter<ContentType> converter = new ContentAndStatsToJsonConverter<>();
+        return converter.convertContent(storage);
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/justinefactory/reading/parsers/IntegerPlainContentParserTest.java b/src/test/java/com/justinefactory/reading/parsers/IntegerPlainContentParserTest.java
index 8c13d11..594ac81 100644
--- a/src/test/java/com/justinefactory/reading/parsers/IntegerPlainContentParserTest.java
+++ b/src/test/java/com/justinefactory/reading/parsers/IntegerPlainContentParserTest.java
@@ -1,46 +1,56 @@
 package com.justinefactory.reading.parsers;
 
 import com.justinefactory.reading.exceptions.ContentParsingException;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.PlainContent;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 
+import java.util.List;
 import java.util.stream.Stream;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class IntegerPlainContentParserTest {
 
     @ParameterizedTest
     @MethodSource("parseLineWhenContentMeetsConditionsTestData")
-    void parseLineWhenContentMeetsConditions(String content, Integer expectedContent) throws Exception {
+    void parseLineWhenContentMeetsConditions(PlainContent content, Content<Integer> expectedContent) throws Exception {
         //when
         IntegerPlainContentParser contentParser = new IntegerPlainContentParser();
-        Integer integer = contentParser.parseLine(content);
+        Content<Integer> integer = contentParser.parse(content);
 
         //then
-        assertEquals(integer, expectedContent);
+        assertEquals(expectedContent, integer);
     }
 
     static Stream<Arguments> parseLineWhenContentMeetsConditionsTestData() {
         return Stream.of(
-                Arguments.arguments("40000000", 40000000),
-                Arguments.arguments("800000", 800000),
-                Arguments.arguments("3245", 3245),
-                Arguments.arguments("0", 0),
-                Arguments.arguments("-765432",-765432)
+                Arguments.arguments(new PlainContent(List.of("40000000")), new Content<>(40000000)),
+                Arguments.arguments(new PlainContent(List.of("800000")), new Content<>(800000)),
+                Arguments.arguments(new PlainContent(List.of("3245")), new Content<>(3245)),
+                Arguments.arguments(new PlainContent(List.of("0")), new Content<>(0)),
+                Arguments.arguments(new PlainContent(List.of("-765432")), new Content<>(-765432))
         );
     }
 
 
     @ParameterizedTest
-    @ValueSource(strings = {"alex", "brian", "charles","-543,88763"})
-    void parseLineWhenContentDoesNotMeetConditions(String content) {
+    @MethodSource("parseLineWhenContentDoesNotMeetConditionsTestData")
+    void parseLineWhenContentDoesNotMeetConditions(PlainContent content) {
         //when
         IntegerPlainContentParser contentParser = new IntegerPlainContentParser();
 
         //then
-        assertThrows(ContentParsingException.class, () -> contentParser.parseLine(content));
+        assertThrows(ContentParsingException.class, () -> contentParser.parse(content));
+    }
+
+    static Stream<Arguments> parseLineWhenContentDoesNotMeetConditionsTestData() {
+        return Stream.of(
+                Arguments.arguments(new PlainContent(List.of("Plain"))),
+                Arguments.arguments(new PlainContent(List.of("Raw")))
+        );
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/justinefactory/reading/parsers/ThreeElementCsvParserTest.java b/src/test/java/com/justinefactory/reading/parsers/ThreeElementCsvParserTest.java
index bc5312e..8b93935 100644
--- a/src/test/java/com/justinefactory/reading/parsers/ThreeElementCsvParserTest.java
+++ b/src/test/java/com/justinefactory/reading/parsers/ThreeElementCsvParserTest.java
@@ -2,6 +2,8 @@
 
 import com.justinefactory.domain.ThreeElemContent;
 import com.justinefactory.reading.exceptions.ContentParsingException;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.CsvContent;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -15,57 +17,57 @@ class ThreeElementCsvParserTest {
 
     @ParameterizedTest
     @MethodSource("parseLineWhenContentMeetsConditionsTestData")
-    void parseLineWhenContentMeetsConditions(String[] content, ThreeElemContent expectedContent) throws Exception {
+    void parseLineWhenContentMeetsConditions(CsvContent content, Content<ThreeElemContent> expectedContent) throws Exception {
         //when
         ThreeElementCsvParser csvParser = new ThreeElementCsvParser();
 
         //then
-        ThreeElemContent csvLine = csvParser.parseLine(content);
+        Content<ThreeElemContent> csvLine = csvParser.parse(content);
         assertEquals(expectedContent, csvLine);
     }
 
 
     static Stream<Arguments> parseLineWhenContentMeetsConditionsTestData() {
         return Stream.of(
-                Arguments.arguments(new String[]{"1590147349818750700", "-840762737", "ChristopherRobin"}, new ThreeElemContent(1590147349818750700L, -840762737, "ChristopherRobin")),
-                Arguments.arguments(new String[]{"1590147349820800800", "-1345882450", "Owl"}, new ThreeElemContent(1590147349820800800L, -1345882450, "Owl")),
-                Arguments.arguments(new String[]{"1590147349822277700", "1434010513", "Heffalumps"}, new ThreeElemContent(1590147349822277700L, 1434010513, "Heffalumps")),
-                Arguments.arguments(new String[]{"1590147349823733800", "1822510187", "Woozles"}, new ThreeElemContent(1590147349823733800L, 1822510187, "Woozles"))
+                Arguments.arguments(new CsvContent(new String[]{"1590147349818750700", "-840762737", "ChristopherRobin"}), new Content<>(new ThreeElemContent(1590147349818750700L, -840762737, "ChristopherRobin"))),
+                Arguments.arguments(new CsvContent(new String[]{"1590147349820800800", "-1345882450", "Owl"}), new Content<>(new ThreeElemContent(1590147349820800800L, -1345882450, "Owl"))),
+                Arguments.arguments(new CsvContent(new String[]{"1590147349822277700", "1434010513", "Heffalumps"}), new Content<>(new ThreeElemContent(1590147349822277700L, 1434010513, "Heffalumps"))),
+                Arguments.arguments(new CsvContent(new String[]{"1590147349823733800", "1822510187", "Woozles"}), new Content<>(new ThreeElemContent(1590147349823733800L, 1822510187, "Woozles")))
         );
     }
 
 
     @ParameterizedTest
     @MethodSource("parseLineWhenLineInFileCorruptTestData")
-    void parseLineWhenLineInFileCorrupt(String[] content) {
+    void parseLineWhenLineInFileCorrupt(CsvContent content) {
         //when
         ThreeElementCsvParser csvParser = new ThreeElementCsvParser();
 
         //then
-        assertThrows(ContentParsingException.class, () -> csvParser.parseLine(content));
+        assertThrows(ContentParsingException.class, () -> csvParser.parse(content));
     }
 
     static Stream<Arguments> parseLineWhenLineInFileCorruptTestData() {
         return Stream.of(
-                Arguments.of((Object) new String[]{"1590147349818750700", "ChristopherRobin"}),
-                Arguments.of((Object) new String[]{"1590147349818750700", "840762737", "ChristopherRobin", "ChristopherRobin"})
+                Arguments.arguments(new CsvContent(new String[]{"1590147349818750700", "ChristopherRobin"})),
+                Arguments.arguments(new CsvContent(new String[]{"1590147349818750700", "ChristopherRobin", "ChristopherRobin"}))
         );
     }
 
 
     @ParameterizedTest
     @MethodSource("parseLineWhenColumnsAreMisplacedInFileTestData")
-    void parseLineWhenColumnsAreMisplacedInFile(String[] content) {
+    void parseLineWhenColumnsAreMisplacedInFile(CsvContent content) {
         //when
         ThreeElementCsvParser csvParser = new ThreeElementCsvParser();
 
         //then
-        assertThrows(ContentParsingException.class, () -> csvParser.parseLine(content));
+        assertThrows(ContentParsingException.class, () -> csvParser.parse(content));
     }
 
     static Stream<Arguments> parseLineWhenColumnsAreMisplacedInFileTestData() {
         return Stream.of(
-                Arguments.of((Object) new String[]{"-1345882450", "Owl", "1590147349820800800"})
-        );
+                Arguments.arguments(new CsvContent(new String[]{"-1345882450", "Owl", "1590147349820800800"}))
+                );
     }
 }
diff --git a/src/test/java/com/justinefactory/reading/readers/ContentReadingServiceTest.java b/src/test/java/com/justinefactory/reading/readers/ContentReadingServiceTest.java
index ca5350f..883c8fb 100644
--- a/src/test/java/com/justinefactory/reading/readers/ContentReadingServiceTest.java
+++ b/src/test/java/com/justinefactory/reading/readers/ContentReadingServiceTest.java
@@ -5,7 +5,9 @@
 import com.justinefactory.reading.parsers.IntegerPlainContentParser;
 import com.justinefactory.reading.parsers.ThreeElementCsvParser;
 import com.justinefactory.reading.service.ContentReadingService;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.CsvContent;
+import com.justinefactory.writing.domain.PlainContent;
 import org.junit.jupiter.api.Test;
 
 import java.nio.file.Path;
@@ -19,7 +21,7 @@ class ContentReadingServiceTest {
     void processContentWhenProcessingCSVFile() throws Exception {
         //given
         Path filePath = getPathToResource("example-csv-file-for-tests.csv");
-        ContentStorage<ThreeElemContent> expectedContent = new ContentStorage<>();
+        Content<ThreeElemContent> expectedContent = new Content<>();
         expectedContent.addContent(new ThreeElemContent(Long.parseLong("1590147349818750700"), -840762737, "ChristopherRobin"));
         expectedContent.addContent(new ThreeElemContent(Long.parseLong("1590147349820800800"), -1345882450, "Owl"));
         expectedContent.addContent(new ThreeElemContent(Long.parseLong("1590147349822277700"), 1434010513, "Heffalumps"));
@@ -30,8 +32,8 @@ void processContentWhenProcessingCSVFile() throws Exception {
         PathInfo fileData = new PathInfo(filePath);
         CsvContentReader contentReader = new CsvContentReader(fileData);
         ThreeElementCsvParser csvParser = new ThreeElementCsvParser();
-        ContentReadingService contentReadingService = new ContentReadingService(contentReader, csvParser);
-        ContentStorage<ThreeElemContent> content = contentReadingService.processContent();
+        ContentReadingService<CsvContent, ThreeElemContent> contentReadingService = new ContentReadingService<>(contentReader, csvParser);
+        Content<ThreeElemContent> content = contentReadingService.processContent();
 
 
         //then
@@ -42,7 +44,7 @@ void processContentWhenProcessingCSVFile() throws Exception {
     void processContentWhenProcessingPlainFile() throws Exception {
         //given
         PathInfo fileData = new PathInfo(getPathToResource("txt-file-content-integers.txt"));
-        ContentStorage<Integer> expectedContent = new ContentStorage<>();
+        Content<Integer> expectedContent = new Content<>();
         expectedContent.addContent(40000000);
         expectedContent.addContent(800000);
         expectedContent.addContent(3245);
@@ -51,8 +53,8 @@ void processContentWhenProcessingPlainFile() throws Exception {
         //when
         PlainContentReader contentReader = new PlainContentReader(fileData);
         IntegerPlainContentParser intParser = new IntegerPlainContentParser();
-        ContentReadingService contentReadingService = new ContentReadingService(contentReader, intParser);
-        ContentStorage<Integer> content = contentReadingService.processContent();
+        ContentReadingService<PlainContent, Integer> contentReadingService = new ContentReadingService<>(contentReader, intParser);
+        Content<Integer> content = contentReadingService.processContent();
 
 
         //then
diff --git a/src/test/java/com/justinefactory/reading/readers/CsvContentReaderTest.java b/src/test/java/com/justinefactory/reading/readers/CsvContentReaderTest.java
index 367d25e..80db532 100644
--- a/src/test/java/com/justinefactory/reading/readers/CsvContentReaderTest.java
+++ b/src/test/java/com/justinefactory/reading/readers/CsvContentReaderTest.java
@@ -2,7 +2,7 @@
 
 import com.justinefactory.domain.PathInfo;
 import com.justinefactory.reading.exceptions.SourceFileIsEmptyException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.CsvContent;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
@@ -20,9 +20,9 @@ void readContentWhenFileMeetsConditions() throws Exception {
         //when
         PathInfo fileData = new PathInfo(filePath);
         CsvContentReader contentReader = new CsvContentReader(fileData);
-        ContentStorage<String[]> content = contentReader.readContent();
+        CsvContent content = contentReader.readContent();
         //then
-        assertNotEquals(0, content.getContentSize());
+        assertNotEquals(0, content.size());
     }
 
 
diff --git a/src/test/java/com/justinefactory/reading/readers/PlainContentReaderTest.java b/src/test/java/com/justinefactory/reading/readers/PlainContentReaderTest.java
index 8788b7d..d315ae7 100644
--- a/src/test/java/com/justinefactory/reading/readers/PlainContentReaderTest.java
+++ b/src/test/java/com/justinefactory/reading/readers/PlainContentReaderTest.java
@@ -2,7 +2,7 @@
 
 import com.justinefactory.domain.PathInfo;
 import com.justinefactory.reading.exceptions.SourceFileIsEmptyException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.PlainContent;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
@@ -18,11 +18,11 @@ class PlainContentReaderTest {
     void readContentWhenFileContentMeetsConditions() throws Exception {
         //given
         PathInfo fileData = new PathInfo(getPathToResource("txt-file-content-integers.txt"));
-        ContentStorage<String> expectedContent = new ContentStorage<>(Arrays.asList("40000000", "800000", "3245", "2143567"));
+        PlainContent expectedContent = new PlainContent(Arrays.asList("40000000", "800000", "3245", "2143567"));
 
         //when
         PlainContentReader contentReader = new PlainContentReader(fileData);
-        ContentStorage<String> content = contentReader.readContent();
+        PlainContent content = contentReader.readContent();
 
         //then
         assertEquals(content, expectedContent);
diff --git a/src/test/java/com/justinefactory/sending/domain/ContentAndStatsStorageTest.java b/src/test/java/com/justinefactory/sending/domain/ContentAndStatsStorageTest.java
index fc93254..d4dc13b 100644
--- a/src/test/java/com/justinefactory/sending/domain/ContentAndStatsStorageTest.java
+++ b/src/test/java/com/justinefactory/sending/domain/ContentAndStatsStorageTest.java
@@ -1,7 +1,7 @@
 package com.justinefactory.sending.domain;
 
 import com.justinefactory.stats.domain.Stats;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -12,11 +12,11 @@ class ContentAndStatsStorageTest {
     @Test
     void createContentAndStatsStorageWhenContentMeetsConditions() {
         // given
-        ContentStorage<Integer> content = new ContentStorage<>(50);
+        Content<Integer> content = new Content<>(50);
         Stats<Integer> stats = new Stats<>(1, 1, 50);
 
         //when
-        ContentAndStatsStorage<Integer> contentAndStatsStorage = new ContentAndStatsStorage<>(content, stats);
+        ContentAndStats<Integer> contentAndStatsStorage = new ContentAndStats<>(content, stats);
 
         //then
         assertEquals(content, contentAndStatsStorage.getContent());
@@ -26,11 +26,11 @@ void createContentAndStatsStorageWhenContentMeetsConditions() {
     @Test
     void createContentAndStatsStorageWhenContentEmpty() {
         // given
-        ContentStorage<Integer> content = new ContentStorage<>();
+        Content<Integer> content = new Content<>();
         Stats<Integer> stats = new Stats<>(1, 1, 50);
 
         //then
-        assertThrows(IllegalArgumentException.class, () -> new ContentAndStatsStorage<>(content, stats));
+        assertThrows(IllegalArgumentException.class, () -> new ContentAndStats<>(content, stats));
     }
 
     @Test
@@ -39,15 +39,15 @@ void createContentAndStatsStorageWhenContentIsNull() {
         Stats<Integer> stats = new Stats<>(1, 1, 50);
 
         //then
-        assertThrows(IllegalArgumentException.class, () -> new ContentAndStatsStorage<>(null, stats));
+        assertThrows(IllegalArgumentException.class, () -> new ContentAndStats<>(null, stats));
     }
 
     @Test
     void createContentAndStatsStorageWhenStatsAreNull() {
         // given
-        ContentStorage<Integer> content = new ContentStorage<>(50);
+        Content<Integer> content = new Content<>(50);
 
         //then
-        assertThrows(IllegalArgumentException.class, () -> new ContentAndStatsStorage<>(content, null));
+        assertThrows(IllegalArgumentException.class, () -> new ContentAndStats<>(content, null));
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/justinefactory/stats/calculators/IntegerContentStatsCalculatorTest.java b/src/test/java/com/justinefactory/stats/calculators/IntegerContentStatsCalculatorTest.java
index 4b79340..3458a4c 100644
--- a/src/test/java/com/justinefactory/stats/calculators/IntegerContentStatsCalculatorTest.java
+++ b/src/test/java/com/justinefactory/stats/calculators/IntegerContentStatsCalculatorTest.java
@@ -2,7 +2,7 @@
 
 import com.justinefactory.stats.domain.Stats;
 import com.justinefactory.stats.exceptions.StatsCalculatingException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
@@ -24,7 +24,7 @@ void calculateStatsWhenContentIsNull() {
     @Test
     void calculateStatsWhenContentEmpty() {
         //given
-        ContentStorage<Integer> content = new ContentStorage<>();
+        Content<Integer> content = new Content<>();
 
         //when
         IntegerContentStatsCalculator calculator = new IntegerContentStatsCalculator();
@@ -37,7 +37,7 @@ void calculateStatsWhenContentEmpty() {
     @Test
     void calculateStatsWhenContentHas1Element() throws StatsCalculatingException {
         //given
-        ContentStorage<Integer> content = new ContentStorage<>(10);
+        Content<Integer> content = new Content<>(10);
         Stats<Integer> expectedStats = new Stats<>(1, 1, 10);
         IntegerContentStatsCalculator calculator = new IntegerContentStatsCalculator();
 
@@ -52,7 +52,7 @@ void calculateStatsWhenContentHas1Element() throws StatsCalculatingException {
     @Test
     void calculateStatsWhenContentHasMoreElementsAndAllUnique() throws StatsCalculatingException {
         //given
-        ContentStorage<Integer> content = new ContentStorage<>(List.of(10, 50, 40, 20, 70, 130, 1));
+        Content<Integer> content = new Content<>(List.of(10, 50, 40, 20, 70, 130, 1));
         Stats<Integer> expectedStats = new Stats<>(7, 7, 130);
         IntegerContentStatsCalculator calculator = new IntegerContentStatsCalculator();
 
@@ -67,7 +67,7 @@ void calculateStatsWhenContentHasMoreElementsAndAllUnique() throws StatsCalculat
     @Test
     void calculateStatsWhenContentHasMoreNonUniqueElements() throws StatsCalculatingException {
         //given
-        ContentStorage<Integer> content = new ContentStorage<>(List.of(10, 20, 14, 20, 20, 12, 1));
+        Content<Integer> content = new Content<>(List.of(10, 20, 14, 20, 20, 12, 1));
         Stats<Integer> expectedStats = new Stats<>(7, 5, 20);
         IntegerContentStatsCalculator calculator = new IntegerContentStatsCalculator();
 
diff --git a/src/test/java/com/justinefactory/stats/calculators/ThreeElementContentStatsCalculatorTest.java b/src/test/java/com/justinefactory/stats/calculators/ThreeElementContentStatsCalculatorTest.java
index 6dbfefd..5e7a085 100644
--- a/src/test/java/com/justinefactory/stats/calculators/ThreeElementContentStatsCalculatorTest.java
+++ b/src/test/java/com/justinefactory/stats/calculators/ThreeElementContentStatsCalculatorTest.java
@@ -3,7 +3,7 @@
 import com.justinefactory.domain.ThreeElemContent;
 import com.justinefactory.stats.domain.Stats;
 import com.justinefactory.stats.exceptions.StatsCalculatingException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -23,7 +23,7 @@ void calculateStatsWhenCollectionIsNull() {
     @Test
     void calculateStatsWhenCollectionIsEmpty() {
         //given
-        ContentStorage<ThreeElemContent> content = new ContentStorage<>();
+        Content<ThreeElemContent> content = new Content<>();
 
         //when
         ThreeElementContentStatsCalculator calculator = new ThreeElementContentStatsCalculator();
@@ -36,7 +36,7 @@ void calculateStatsWhenCollectionIsEmpty() {
     void calculateStatsWhen1Element() throws StatsCalculatingException {
         //given
         ThreeElemContent maxThreeElemContent = new ThreeElemContent(1590147349818750700L, -840762737, "ChristopherRobin");
-        ContentStorage<ThreeElemContent> content = new ContentStorage<>();
+        Content<ThreeElemContent> content = new Content<>();
         content.addContent(maxThreeElemContent);
         Stats<ThreeElemContent> expectedStats = new Stats<>(1, 1, maxThreeElemContent);
 
@@ -52,7 +52,7 @@ void calculateStatsWhen1Element() throws StatsCalculatingException {
     void calculateStatsWhen2DistinctElements() throws StatsCalculatingException {
         //given
         ThreeElemContent maxThreeElemContent = new ThreeElemContent(1590147349818750700L, 1345882450, "Owl");
-        ContentStorage<ThreeElemContent> content = new ContentStorage<>();
+        Content<ThreeElemContent> content = new Content<>();
         content.addContent(new ThreeElemContent(1590147349818750700L, -840762737, "ChristopherRobin"));
         content.addContent(maxThreeElemContent);
         Stats<ThreeElemContent> expectedStats = new Stats<>(2, 2, maxThreeElemContent);
@@ -69,7 +69,7 @@ void calculateStatsWhen2DistinctElements() throws StatsCalculatingException {
     void calculateStatsWhen3ElementsBut2Distinct() throws StatsCalculatingException {
         //given
         ThreeElemContent maxThreeElemContent = new ThreeElemContent(1590147349818750700L, 1345882450, "Owl");
-        ContentStorage<ThreeElemContent> content = new ContentStorage<>();
+        Content<ThreeElemContent> content = new Content<>();
         content.addContent(new ThreeElemContent(1590147349818750700L, -840762737, "ChristopherRobin"));
         content.addContent(maxThreeElemContent);
         content.addContent(maxThreeElemContent);
@@ -87,7 +87,7 @@ void calculateStatsWhen3ElementsBut2Distinct() throws StatsCalculatingException
     void calculateStatsWhen2ElementsBut1Distinct_MakingSureTimeStampIsExcludedFromDefiningDistinct() throws StatsCalculatingException {
         //given
         ThreeElemContent maxThreeElemContent = new ThreeElemContent(1590147349818750700L, 1434010513, "Owl");
-        ContentStorage<ThreeElemContent> content = new ContentStorage<>();
+        Content<ThreeElemContent> content = new Content<>();
         content.addContent(maxThreeElemContent);
         content.addContent(new ThreeElemContent(1590147349818750888L, 1434010513, "Owl"));
 
@@ -105,7 +105,7 @@ void calculateStatsWhen2ElementsBut1Distinct_MakingSureTimeStampIsExcludedFromDe
     void calculateStatsWhen2DistinctElements_MakingSureACombinationOfStringAndRandomIntIsTakenToDefineDistinct() throws StatsCalculatingException {
         //given
         ThreeElemContent maxThreeElementContent = new ThreeElemContent(1590147349818750800L, 1434010513, "ChristopherRobin");
-        ContentStorage<ThreeElemContent> content = new ContentStorage<>();
+        Content<ThreeElemContent> content = new Content<>();
         content.addContent(new ThreeElemContent(1590147349818750700L, -840762737, "ChristopherRobin"));
         content.addContent(maxThreeElementContent);
 
diff --git a/src/test/java/com/justinefactory/writing/converters/ContentAndStatsToJsonConverterTest.java b/src/test/java/com/justinefactory/writing/converters/ContentAndStatsToJsonConverterTest.java
index 9453646..5afda7f 100644
--- a/src/test/java/com/justinefactory/writing/converters/ContentAndStatsToJsonConverterTest.java
+++ b/src/test/java/com/justinefactory/writing/converters/ContentAndStatsToJsonConverterTest.java
@@ -1,9 +1,10 @@
 package com.justinefactory.writing.converters;
 
 import com.justinefactory.domain.ThreeElemContent;
-import com.justinefactory.sending.domain.ContentAndStatsStorage;
+import com.justinefactory.sending.domain.ContentAndStats;
 import com.justinefactory.stats.domain.Stats;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.JsonContent;
 import com.justinefactory.writing.exceptions.ContentConversion2ReadyToWriteException;
 import com.justinefactory.writing.exceptions.ContentWritingException;
 import org.junit.jupiter.api.Test;
@@ -48,20 +49,20 @@ void createContentWhenThreeElemContentConvertedAndMeetsConditions() throws Conte
                 "    }\n" +
                 "  }\n" +
                 "}";
-        ContentStorage<ThreeElemContent> threeElemContentContentStorage = new ContentStorage<>();
+        Content<ThreeElemContent> threeElemContentContentStorage = new Content<>();
         ThreeElemContent threeElemContentContent = new ThreeElemContent(1590147349818750700L, -840762737, "ChristopherRobin");
         threeElemContentContentStorage.addContent(threeElemContentContent);
 
         Stats<ThreeElemContent> stats = new Stats<>(1, 1, threeElemContentContent);
-        ContentAndStatsStorage<ThreeElemContent> content = new ContentAndStatsStorage<>(threeElemContentContentStorage, stats);
+        ContentAndStats<ThreeElemContent> content = new ContentAndStats<>(threeElemContentContentStorage, stats);
 
         ContentAndStatsToJsonConverter<ThreeElemContent> converter = new ContentAndStatsToJsonConverter<>();
 
         //when
-        ContentStorage<String> json = converter.convertContent(content);
+        JsonContent jsonContent = converter.convertContent(content);
 
         //then
-        assertEquals(expectedContent, json.getContent(0));
+        assertEquals(expectedContent, jsonContent.getContent());
     }
 
 
diff --git a/src/test/java/com/justinefactory/writing/converters/IntegersToLinesConverterTest.java b/src/test/java/com/justinefactory/writing/converters/IntegersToLinesConverterTest.java
index a651b1d..f876a50 100644
--- a/src/test/java/com/justinefactory/writing/converters/IntegersToLinesConverterTest.java
+++ b/src/test/java/com/justinefactory/writing/converters/IntegersToLinesConverterTest.java
@@ -1,6 +1,7 @@
 package com.justinefactory.writing.converters;
 
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.PlainContent;
 import com.justinefactory.writing.exceptions.ContentConversion2ReadyToWriteException;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -30,7 +31,7 @@ void convertDataWhenNull() {
     void convertDataWhenIsEmpty() {
         //given
         IntegersToLinesConverter converter = new IntegersToLinesConverter();
-        ContentStorage<Integer> input = new ContentStorage<>();
+        Content<Integer> input = new Content<>();
 
         //then
         assertThrows(ContentConversion2ReadyToWriteException.class, () -> converter.convertContent(input));
@@ -39,12 +40,12 @@ void convertDataWhenIsEmpty() {
 
     @ParameterizedTest
     @MethodSource("conversionData")
-    void convertDataWhenContentMeetsConditions(ContentStorage<Integer> input, ContentStorage<String> expectedContent) throws ContentConversion2ReadyToWriteException {
+    void convertDataWhenContentMeetsConditions(Content<Integer> input, PlainContent expectedContent) throws ContentConversion2ReadyToWriteException {
         //given
         IntegersToLinesConverter converter = new IntegersToLinesConverter();
 
         //when
-        ContentStorage<String> actualContent = converter.convertContent(input);
+        PlainContent actualContent = converter.convertContent(input);
 
         //then
         assertEquals(actualContent, expectedContent);
@@ -52,9 +53,9 @@ void convertDataWhenContentMeetsConditions(ContentStorage<Integer> input, Conten
 
     static Stream<Arguments> conversionData() {
         return Stream.of(
-                Arguments.arguments(new ContentStorage<>(Collections.singletonList(1)), new ContentStorage<>(Collections.singletonList("1"))),
-                Arguments.arguments(new ContentStorage<>(Arrays.asList(1, 2)), new ContentStorage<>(Arrays.asList("1", "2"))),
-                Arguments.arguments(new ContentStorage<>(Arrays.asList(1, 2, 3, 4)), new ContentStorage<>(Arrays.asList("1", "2", "3", "4")))
+                Arguments.arguments(new Content<>(Collections.singletonList(1)), new PlainContent(Collections.singletonList("1"))),
+                Arguments.arguments(new Content<>(Arrays.asList(1, 2)), new PlainContent(Arrays.asList("1", "2"))),
+                Arguments.arguments(new Content<>(Arrays.asList(1, 2, 3, 4)), new PlainContent(Arrays.asList("1", "2", "3", "4")))
         );
     }
 
diff --git a/src/test/java/com/justinefactory/writing/converters/ThreeElementContentToCsvLinesConverterTest.java b/src/test/java/com/justinefactory/writing/converters/ThreeElementContentToCsvLinesConverterTest.java
index 496b74c..8edd962 100644
--- a/src/test/java/com/justinefactory/writing/converters/ThreeElementContentToCsvLinesConverterTest.java
+++ b/src/test/java/com/justinefactory/writing/converters/ThreeElementContentToCsvLinesConverterTest.java
@@ -1,7 +1,8 @@
 package com.justinefactory.writing.converters;
 
 import com.justinefactory.domain.ThreeElemContent;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
+import com.justinefactory.writing.domain.CsvContent;
 import com.justinefactory.writing.exceptions.ContentConversion2ReadyToWriteException;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -19,7 +20,7 @@ class ThreeElementContentToCsvLinesConverterTest {
     void convertDataWhenContentIsEmpty() {
         //given
         ThreeElementContentToCsvLinesConverter converter = new ThreeElementContentToCsvLinesConverter();
-        ContentStorage<ThreeElemContent> input = new ContentStorage<>();
+        Content<ThreeElemContent> input = new Content<>();
 
         //then
         assertThrows(ContentConversion2ReadyToWriteException.class, () -> converter.convertContent(input));
@@ -28,15 +29,15 @@ void convertDataWhenContentIsEmpty() {
 
     @ParameterizedTest
     @MethodSource("conversionData")
-    void convertDataWhenContentMeetsConditions(ContentStorage<ThreeElemContent> input, ContentStorage<String[]> expectedContent) throws ContentConversion2ReadyToWriteException {
+    void convertDataWhenContentMeetsConditions(Content<ThreeElemContent> input, CsvContent expectedContent) throws ContentConversion2ReadyToWriteException {
         //given
         ThreeElementContentToCsvLinesConverter converter = new ThreeElementContentToCsvLinesConverter();
 
         //when
-        ContentStorage<String[]> actualContent = converter.convertContent(input);
+        CsvContent actualContent = converter.convertContent(input);
 
         //then
-        for (int i = 0; i < expectedContent.getContentSize(); i++) {
+        for (int i = 0; i < expectedContent.getContent().size(); i++) {
             assertEquals(expectedContent.getContent(i)[0], actualContent.getContent(i)[0]);
             assertEquals(expectedContent.getContent(i)[1], actualContent.getContent(i)[1]);
             assertEquals(expectedContent.getContent(i)[2], actualContent.getContent(i)[2]);
@@ -47,14 +48,14 @@ static Stream<Arguments> conversionData() {
         ThreeElemContent firstThreeElemContent = new ThreeElemContent(1590147349818750700L, 1345882450, "Owl");
         ThreeElemContent secondThreeElemContent = new ThreeElemContent(1590147349818759790L, -45882470, "Fluff");
 
-        ContentStorage<ThreeElemContent> firstInput = new ContentStorage<>();
+        Content<ThreeElemContent> firstInput = new Content<>();
         firstInput.addContent(firstThreeElemContent);
-        ContentStorage<ThreeElemContent> secondInput = firstInput;
+        Content<ThreeElemContent> secondInput = firstInput;
         secondInput.addContent(secondThreeElemContent);
 
-        ContentStorage<String[]> firstString = new ContentStorage<>();
+        CsvContent firstString = new CsvContent();
         firstString.addContent(new String[]{firstThreeElemContent.getTimeStamp().toString(), firstThreeElemContent.getRandomInt().toString(), firstThreeElemContent.getRandomString()});
-        ContentStorage<String[]> secondString = firstString;
+        CsvContent secondString = firstString;
         secondString.addContent(new String[]{secondThreeElemContent.getTimeStamp().toString(), secondThreeElemContent.getRandomInt().toString(), secondThreeElemContent.getRandomString()});
 
 
diff --git a/src/test/java/com/justinefactory/writing/domain/ContentStorageTest.java b/src/test/java/com/justinefactory/writing/domain/ContentStorageTest.java
index 0c040b7..12fa84c 100644
--- a/src/test/java/com/justinefactory/writing/domain/ContentStorageTest.java
+++ b/src/test/java/com/justinefactory/writing/domain/ContentStorageTest.java
@@ -16,7 +16,7 @@ void createContentStorageWhenInstertingContentAsNull() {
         String string = null;
 
         //then
-        assertThrows(IllegalArgumentException.class, () -> new ContentStorage<>(string));
+        assertThrows(IllegalArgumentException.class, () -> new Content<>(string));
     }
 
     @Test
@@ -25,7 +25,7 @@ void createContentStorageWhenInstertingContentThatMeetsConditions() {
         String string = "Tiger";
 
         //when
-        ContentStorage<String> contentStorage = new ContentStorage<>(string);
+        Content<String> contentStorage = new Content<>(string);
 
         //then
         assertEquals(string, contentStorage.getContent(0));
@@ -39,7 +39,7 @@ void createContentStorageWhenInstertingListOfContentWithNullItem() {
         list.add(null);
 
         //then
-        assertThrows(IllegalArgumentException.class, () -> new ContentStorage<>(list));
+        assertThrows(IllegalArgumentException.class, () -> new Content<>(list));
     }
 
     @Test
@@ -48,7 +48,7 @@ void createContentStorageWhenInstertingListOfContentNull() {
         List<String> list = null;
 
         //then
-        assertThrows(IllegalArgumentException.class, () -> new ContentStorage<>(list));
+        assertThrows(IllegalArgumentException.class, () -> new Content<>(list));
     }
 
     @Test
@@ -57,17 +57,17 @@ void createContentStorageWhenInstertingListOfContentThatMeetsConditions() {
         List<Integer> list = new ArrayList<>(List.of(1, 15, 32));
 
         //when
-        ContentStorage<Integer> contentStorage = new ContentStorage<>(list);
+        Content<Integer> contentStorage = new Content<>(list);
 
         //then
-        assertEquals(list, contentStorage.getAllContent());
+        assertEquals(list, contentStorage.getContent());
     }
 
 
     @Test
     void createContentStorageWhenAddingNull() {
         //given
-        ContentStorage<String> content = new ContentStorage<>();
+        Content<String> content = new Content<>();
 
         //then
         assertThrows(IllegalArgumentException.class, () -> content.addContent(null));
@@ -77,7 +77,7 @@ void createContentStorageWhenAddingNull() {
     @Test
     void createContentStorageWhenAddingContentThatMeetsConditions() {
         //given
-        ContentStorage<String> content = new ContentStorage<>();
+        Content<String> content = new Content<>();
         String string = "Tiger";
 
         //when
diff --git a/src/test/java/com/justinefactory/writing/domain/JsonContentTest.java b/src/test/java/com/justinefactory/writing/domain/JsonContentTest.java
new file mode 100644
index 0000000..9c119af
--- /dev/null
+++ b/src/test/java/com/justinefactory/writing/domain/JsonContentTest.java
@@ -0,0 +1,48 @@
+package com.justinefactory.writing.domain;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class JsonContentTest {
+
+    @Test
+    public void createJsonContentWhenJsonIsNull() {
+        //given
+        String json = null;
+
+        //then
+        assertThrows(IllegalArgumentException.class, () -> new JsonContent(json));
+    }
+
+
+    @Test
+    public void createJsonContentWhenJsonIsEmpty() {
+        //given
+        String json = "";
+
+        //then
+        assertThrows(IllegalArgumentException.class, () -> new JsonContent(json));
+    }
+
+
+    @Test
+    public void createJsonContentWhenJsonMeetsConditions() {
+        //given
+        String json = "{\"content\": [\n" +
+                "      {\n" +
+                "        \"timeStamp\": 1590147349818750700,\n" +
+                "        \"randomInt\": -840762737,\n" +
+                "        \"randomString\": \"ChristopherRobin\"\n" +
+                "      }\n" +
+                "    ]\n";
+
+        //when
+        JsonContent jsonContent = new JsonContent(json);
+
+        //then
+        assertEquals(json, jsonContent.getContent());
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/justinefactory/writing/generators/RandomIntegerGeneratorTest.java b/src/test/java/com/justinefactory/writing/generators/RandomIntegerGeneratorTest.java
index b3ae51c..4b570be 100644
--- a/src/test/java/com/justinefactory/writing/generators/RandomIntegerGeneratorTest.java
+++ b/src/test/java/com/justinefactory/writing/generators/RandomIntegerGeneratorTest.java
@@ -1,6 +1,6 @@
 package com.justinefactory.writing.generators;
 
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import org.junit.jupiter.api.Test;
 
 import java.util.Random;
@@ -17,7 +17,7 @@ void generateRandomContent() {
 
         //when
         int nLines = 5;
-        ContentStorage<Integer> newContent = newGenerator.generateContent(nLines);
+        Content<Integer> newContent = newGenerator.generateContent(nLines);
 
         //then
         assertEquals(newContent.getContentSize(), nLines);
@@ -31,7 +31,7 @@ void generateRandomContentWhen0() {
 
         //when
         int nLines = 0;
-        ContentStorage<Integer> content = randomGenerator.generateContent(nLines);
+        Content<Integer> content = randomGenerator.generateContent(nLines);
 
         //then
         assertEquals(content.getContentSize(), 0);
diff --git a/src/test/java/com/justinefactory/writing/generators/RandomStringGeneratorFromFileTest.java b/src/test/java/com/justinefactory/writing/generators/RandomStringGeneratorFromFileTest.java
index df24902..a1b3a8a 100644
--- a/src/test/java/com/justinefactory/writing/generators/RandomStringGeneratorFromFileTest.java
+++ b/src/test/java/com/justinefactory/writing/generators/RandomStringGeneratorFromFileTest.java
@@ -1,7 +1,7 @@
 package com.justinefactory.writing.generators;
 
 import com.justinefactory.domain.PathInfo;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import com.justinefactory.writing.domain.TwoElemContent;
 import com.justinefactory.writing.exceptions.FileWithStringsToGenerateContentIsEmptyException;
 import org.junit.jupiter.api.Assertions;
@@ -40,7 +40,7 @@ void generateStringContentWhen1String() throws Exception {
 
         //when
         int nLines = 5;
-        ContentStorage<TwoElemContent> newContent = newGenerator.generateContent(nLines);
+        Content<TwoElemContent> newContent = newGenerator.generateContent(nLines);
 
         //then
         assertEquals(newContent.getContentSize(), nLines);
@@ -61,7 +61,7 @@ void generateTimeStampContent() throws Exception {
         //when
         Long timeStart = getCurrentTimeInNanoSeconds();
         int nLines = 3;
-        ContentStorage<TwoElemContent> newContent = newGenerator.generateContent(nLines);
+        Content<TwoElemContent> newContent = newGenerator.generateContent(nLines);
         Long timeStop = getCurrentTimeInNanoSeconds();
 
         //then
diff --git a/src/test/java/com/justinefactory/writing/generators/ThreeElementContentGeneratorTest.java b/src/test/java/com/justinefactory/writing/generators/ThreeElementContentGeneratorTest.java
index d85bb26..fd2ee04 100644
--- a/src/test/java/com/justinefactory/writing/generators/ThreeElementContentGeneratorTest.java
+++ b/src/test/java/com/justinefactory/writing/generators/ThreeElementContentGeneratorTest.java
@@ -2,7 +2,7 @@
 
 import com.justinefactory.domain.PathInfo;
 import com.justinefactory.domain.ThreeElemContent;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.Content;
 import org.junit.jupiter.api.Test;
 
 import java.nio.file.Path;
@@ -25,7 +25,7 @@ void generateContentWhenRandom() throws Exception {
 
         //when
         int nLines = 12;
-        ContentStorage<ThreeElemContent> new3ElemContent = new3ElemGenerator.generateContent(nLines);
+        Content<ThreeElemContent> new3ElemContent = new3ElemGenerator.generateContent(nLines);
 
         //then
         assertEquals(new3ElemContent.getContentSize(), nLines);
diff --git a/src/test/java/com/justinefactory/writing/writers/PlainFileWriterTest.java b/src/test/java/com/justinefactory/writing/writers/PlainFileWriterTest.java
deleted file mode 100644
index 6d65ede..0000000
--- a/src/test/java/com/justinefactory/writing/writers/PlainFileWriterTest.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package com.justinefactory.writing.writers;
-
-import com.justinefactory.domain.PathInfo;
-import com.justinefactory.testutil.CreateAndDeleteFilesBeforeAfterAll;
-import com.justinefactory.writing.domain.ContentStorage;
-import com.justinefactory.writing.writers.file.writers.PlainFileWriter;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-
-class PlainFileWriterTest {
-
-    static Path dir;
-    @BeforeAll
-    static void createDirsBeforeAll() throws Exception {
-        dir = CreateAndDeleteFilesBeforeAfterAll.createTemporaryDirectory();
-    }
-
-    @AfterAll
-    static void removeDirsAfterAll() throws Exception {
-        CreateAndDeleteFilesBeforeAfterAll.removeAllDirs(dir);
-    }
-
-    @Test
-    void write2FileWhenWritingRandomInteger() throws Exception {
-        //given
-        Path filePath = dir.resolve("doc.csv");
-        PathInfo file2writeData = new PathInfo(filePath);
-        ContentStorage<String> readyToWriteContent = new ContentStorage<>(List.of("1","2"));
-
-        //when
-        PlainFileWriter writer = new PlainFileWriter();
-        writer.writeContent(readyToWriteContent, file2writeData);
-
-        //then
-        assertTrue(Files.exists(filePath));
-        assertTrue(Files.size(filePath) > 0);
-    }
-
-
-    @Test
-    void write2FileWhenWritingJSON() throws Exception {
-        //given
-        Path filePath = dir.resolve("doc.json");
-        PathInfo file2writeData = new PathInfo(filePath);
-        ContentStorage<String> readyToWriteContent = new ContentStorage<>();
-        readyToWriteContent.addContent("\"{\\n\" +\n" +
-                "                \"  \\\"content\\\": {\\n\" +\n" +
-                "                \"    \\\"content\\\": [\\n\" +\n" +
-                "                \"      {\\n\" +\n" +
-                "                \"        \\\"timeStamp\\\": 1590147349818750700,\\n\" +\n" +
-                "                \"        \\\"randomInt\\\": -840762737,\\n\" +\n" +
-                "                \"        \\\"randomString\\\": \\\"ChristopherRobin\\\"\\n\" +\n" +
-                "                \"      }\\n\" +\n" +
-                "                \"    ]\\n\" +\n" +
-                "                \"  },\\n\" +\n" +
-                "                \"  \\\"stats\\\": {\\n\" +\n" +
-                "                \"    \\\"count\\\": 1,\\n\" +\n" +
-                "                \"    \\\"distinctCount\\\": 1,\\n\" +\n" +
-                "                \"    \\\"max\\\": {\\n\" +\n" +
-                "                \"      \\\"timeStamp\\\": 1590147349818750700,\\n\" +\n" +
-                "                \"      \\\"randomInt\\\": -840762737,\\n\" +\n" +
-                "                \"      \\\"randomString\\\": \\\"ChristopherRobin\\\"\\n\" +\n" +
-                "                \"    }\\n\" +\n" +
-                "                \"  }\\n\" +\n" +
-                "                \"}\";");
-
-        //when
-        PlainFileWriter writer = new PlainFileWriter();
-        writer.writeContent(readyToWriteContent, file2writeData);
-
-        //then
-        assertTrue(Files.exists(filePath));
-        assertTrue(Files.size(filePath) > 0);
-    }
-}
\ No newline at end of file
diff --git a/src/test/java/com/justinefactory/writing/writers/server/writers/JsonAwsWriterTest.java b/src/test/java/com/justinefactory/writing/writers/tocloud/JsonContentAwsWriterTest.java
similarity index 89%
rename from src/test/java/com/justinefactory/writing/writers/server/writers/JsonAwsWriterTest.java
rename to src/test/java/com/justinefactory/writing/writers/tocloud/JsonContentAwsWriterTest.java
index 0b16b13..1e335be 100644
--- a/src/test/java/com/justinefactory/writing/writers/server/writers/JsonAwsWriterTest.java
+++ b/src/test/java/com/justinefactory/writing/writers/tocloud/JsonContentAwsWriterTest.java
@@ -1,10 +1,10 @@
-package com.justinefactory.writing.writers.server.writers;
+package com.justinefactory.writing.writers.tocloud;
 
 import com.amazonaws.services.s3.AmazonS3;
 import com.amazonaws.services.s3.model.DeleteObjectRequest;
 import com.justinefactory.domain.AwsInfo;
 import com.justinefactory.sending.exceptions.AwsSecurityCredentialsException;
-import com.justinefactory.writing.domain.ContentStorage;
+import com.justinefactory.writing.domain.JsonContent;
 import com.justinefactory.writing.exceptions.AwsContentWritingException;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeEach;
@@ -13,7 +13,7 @@
 import static com.justinefactory.testutil.AwsClientCreatorBeforeEach.createAwsClient;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-class JsonAwsWriterTest {
+class JsonContentAwsWriterTest {
 
     private static AmazonS3 awsClient;
     private static String jsonName = "content.json";
@@ -29,12 +29,12 @@ public static void removeObjectFromAws() {
         awsClient.deleteObject(new DeleteObjectRequest(bucketName, jsonName));
     }
 
+
     @Test
     void writeContentWhenContentDoesNotExist() throws AwsContentWritingException {
         //given
         AwsInfo info = new AwsInfo(bucketName, jsonName);
-        ContentStorage<String> readyToWriteContent = new ContentStorage<>();
-        readyToWriteContent.addContent("{\n" +
+        JsonContent readyToWriteContent = new JsonContent("{\n" +
                 "  \"content\": {\n" +
                 "    \"content\": [\n" +
                 "      {\n" +
diff --git a/src/test/java/com/justinefactory/writing/writers/CsvFileWriterTest.java b/src/test/java/com/justinefactory/writing/writers/tofile/CsvFileWriterTest.java
similarity index 78%
rename from src/test/java/com/justinefactory/writing/writers/CsvFileWriterTest.java
rename to src/test/java/com/justinefactory/writing/writers/tofile/CsvFileWriterTest.java
index 173e561..57755e8 100644
--- a/src/test/java/com/justinefactory/writing/writers/CsvFileWriterTest.java
+++ b/src/test/java/com/justinefactory/writing/writers/tofile/CsvFileWriterTest.java
@@ -1,9 +1,8 @@
-package com.justinefactory.writing.writers;
+package com.justinefactory.writing.writers.tofile;
 
 import com.justinefactory.domain.PathInfo;
 import com.justinefactory.testutil.CreateAndDeleteFilesBeforeAfterAll;
-import com.justinefactory.writing.domain.ContentStorage;
-import com.justinefactory.writing.writers.file.writers.CsvFileWriter;
+import com.justinefactory.writing.domain.CsvContent;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -33,7 +32,7 @@ void write2FileWhenFileDoesNotExist() throws Exception {
         //given
         Path filePath = dir.resolve("doc.csv");
         PathInfo file2writeData = new PathInfo(filePath);
-        ContentStorage<String[]> readyToWriteContent = new ContentStorage<>(new String[]{"1590147349818750700", "1345882450", "Owl"});
+        CsvContent readyToWriteContent = new CsvContent(new String[]{"1590147349818750700", "1345882450", "Owl"});
         CsvFileWriter newFileWriter = new CsvFileWriter();
 
         //when
diff --git a/src/test/java/com/justinefactory/writing/writers/tofile/JsonFileWriterTest.java b/src/test/java/com/justinefactory/writing/writers/tofile/JsonFileWriterTest.java
new file mode 100644
index 0000000..2af92a7
--- /dev/null
+++ b/src/test/java/com/justinefactory/writing/writers/tofile/JsonFileWriterTest.java
@@ -0,0 +1,64 @@
+package com.justinefactory.writing.writers.tofile;
+
+import com.justinefactory.domain.PathInfo;
+import com.justinefactory.testutil.CreateAndDeleteFilesBeforeAfterAll;
+import com.justinefactory.writing.domain.JsonContent;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class JsonFileWriterTest {
+
+    static Path dir;
+
+    @BeforeAll
+    static void createDirsBeforeAll() throws Exception {
+        dir = CreateAndDeleteFilesBeforeAfterAll.createTemporaryDirectory();
+    }
+
+    @AfterAll
+    static void removeDirsAfterAll() throws Exception {
+        CreateAndDeleteFilesBeforeAfterAll.removeAllDirs(dir);
+    }
+
+    @Test
+    void write2FileWhenWritingJSON() throws Exception {
+        //given
+        Path filePath = dir.resolve("doc.json");
+        PathInfo file2writeData = new PathInfo(filePath);
+        JsonContent readyToWriteContent = new JsonContent("{\n" +
+                "  \"content\": {\n" +
+                "    \"content\": [\n" +
+                "      {\n" +
+                "        \"timeStamp\": 1590147349818750700,\n" +
+                "        \"randomInt\": -840762737,\n" +
+                "        \"randomString\": \"ChristopherRobin\"\n" +
+                "      }\n" +
+                "    ]\n" +
+                "  },\n" +
+                "  \"stats\": {\n" +
+                "    \"count\": 1,\n" +
+                "    \"distinctCount\": 1,\n" +
+                "    \"max\": {\n" +
+                "      \"timeStamp\": 1590147349818750700,\n" +
+                "      \"randomInt\": -840762737,\n" +
+                "      \"randomString\": \"ChristopherRobin\"\n" +
+                "    }\n" +
+                "  }\n" +
+                "}");
+
+        //when
+        JsonFileWriter writer = new JsonFileWriter();
+        writer.writeContent(readyToWriteContent, file2writeData);
+
+        //then
+        assertTrue(Files.exists(filePath));
+        assertTrue(Files.size(filePath) > 0);
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/justinefactory/writing/writers/tofile/PlainFileWriterTest.java b/src/test/java/com/justinefactory/writing/writers/tofile/PlainFileWriterTest.java
new file mode 100644
index 0000000..316a0c2
--- /dev/null
+++ b/src/test/java/com/justinefactory/writing/writers/tofile/PlainFileWriterTest.java
@@ -0,0 +1,48 @@
+package com.justinefactory.writing.writers.tofile;
+
+import com.justinefactory.domain.PathInfo;
+import com.justinefactory.testutil.CreateAndDeleteFilesBeforeAfterAll;
+import com.justinefactory.writing.domain.PlainContent;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+class PlainFileWriterTest {
+
+    static Path dir;
+
+    @BeforeAll
+    static void createDirsBeforeAll() throws Exception {
+        dir = CreateAndDeleteFilesBeforeAfterAll.createTemporaryDirectory();
+    }
+
+    @AfterAll
+    static void removeDirsAfterAll() throws Exception {
+        CreateAndDeleteFilesBeforeAfterAll.removeAllDirs(dir);
+    }
+
+    @Test
+    void write2FileWhenWritingRandomInteger() throws Exception {
+        //given
+        Path filePath = dir.resolve("doc.csv");
+        PathInfo file2writeData = new PathInfo(filePath);
+        PlainContent readyToWriteContent = new PlainContent(List.of("1", "2"));
+
+        //when
+        PlainFileWriter writer = new PlainFileWriter();
+        writer.writeContent(readyToWriteContent, file2writeData);
+
+        //then
+        assertTrue(Files.exists(filePath));
+        assertTrue(Files.size(filePath) > 0);
+    }
+
+
+}
\ No newline at end of file