diff --git a/src/test/Document.test.ts b/src/test/Document.test.ts
index c5e15c8..8c156e9 100644
--- a/src/test/Document.test.ts
+++ b/src/test/Document.test.ts
@@ -1,7 +1,5 @@
 import { Document, Imperial } from "../lib";
-import { IMPERIAL_TOKEN, RESPONSE } from "./common";
-
-const DAY = 86_400_000;
+import { DAY, IMPERIAL_TOKEN, RESPONSE } from "./common";
 
 describe("Document", () => {
 	const content = "test";
@@ -9,20 +7,25 @@ describe("Document", () => {
 	let document: Document;
 
 	beforeEach(() => {
-		document = new Document(client, { ...RESPONSE.document, content });
+		document = new Document(client, { ...RESPONSE.data, content });
 	});
 
 	it("should be valid", () => {
 		expect(document).toBeInstanceOf(Document);
-		expect(document.id).toBe(RESPONSE.document.documentId);
-		expect(document.link).toBe(`https://${client.rest.hostname}/p/${RESPONSE.document.documentId}`);
+		expect(document.id).toBe(RESPONSE.data.id);
+		expect(document.link).toBe(`https://${client.rest.hostname}/p/${RESPONSE.data.id}`);
 		expect(document.content).toBe(content);
-		expect(document.creation).toBeInstanceOf(Date);
-		expect(document.daysLeft).toBe(null);
+		expect(document.timestamps.creation).toBeInstanceOf(Date);
+		expect(document.timestamps.daysLeft).toBe(null);
 	});
 
 	it("should not be null", () => {
-		document = new Document(client, { ...document.toJSON(), expirationDate: new Date().valueOf() + DAY });
-		expect(document.daysLeft).not.toBe(null);
+		const json = document.toJSON();
+
+		document = new Document(client, {
+			...json,
+			timestamps: { ...json.timestamps, expiration: (new Date().valueOf() + DAY) / 1000 },
+		});
+		expect(document.timestamps.daysLeft).not.toBe(null);
 	});
 });
diff --git a/src/test/common.ts b/src/test/common.ts
index d8cd38c..64e0c42 100644
--- a/src/test/common.ts
+++ b/src/test/common.ts
@@ -1,18 +1,29 @@
+export const DAY = 86_400_000;
+
 export const IMPERIAL_TOKEN = "IMPERIAL-00000000-0000-0000-0000-000000000000";
 
 export const RESPONSE = {
 	success: true,
-	document: {
-		documentId: "bwxUUGyD",
-		language: "auto",
-		imageEmbed: false,
-		instantDelete: true,
-		creationDate: 1617463955786,
-		expirationDate: 1617895955786,
-		allowedEditors: [],
-		encrypted: false,
-		password: null,
-		public: true,
+	data: {
+		id: "HKnB",
+		content: "test",
 		views: 0,
+		links: {
+			raw: "https://staging-balls-api.impb.in/r/HKnB",
+			formatted: "https://staging-balls-api.impb.in/p/HKnB",
+		},
+		timestamps: {
+			creation: (new Date().valueOf() - 7 * DAY) / 1000,
+			expiration: (new Date().valueOf() - DAY) / 1000,
+		},
+		settings: {
+			language: "auto",
+			imageEmbed: false,
+			instantDelete: false,
+			encrypted: false,
+			password: "",
+			public: false,
+			editors: [],
+		},
 	},
 };
diff --git a/src/test/createDocument.test.ts b/src/test/createDocument.test.ts
index 10cb641..32c3693 100644
--- a/src/test/createDocument.test.ts
+++ b/src/test/createDocument.test.ts
@@ -21,46 +21,46 @@ describe("createDocument", () => {
 	});
 
 	it("should create a document - fully valid", async () => {
-		const document = await client.createDocument("i am a valid request");
+		const document = await client.document.create("i am a valid request");
 
-		expect(document.id).toBe(RESPONSE.document.documentId);
-		expect(document.public).toBe(RESPONSE.document.public);
-		expect(document.imageEmbed).toBe(RESPONSE.document.imageEmbed);
+		expect(document.id).toBe(RESPONSE.data.id);
+		expect(document.settings.public).toBe(RESPONSE.data.settings.public);
+		expect(document.settings.imageEmbed).toBe(RESPONSE.data.settings.imageEmbed);
 	});
 
 	it("should create a document - text not a string", async () => {
 		// @ts-expect-error
-		await expect(client.createDocument({})).resolves.toBeInstanceOf(Document);
+		await expect(client.document.create({})).resolves.toBeInstanceOf(Document);
 
 		// @ts-expect-error
-		await expect(client.createDocument([])).resolves.toBeInstanceOf(Document);
+		await expect(client.document.create([])).resolves.toBeInstanceOf(Document);
 
 		// @ts-expect-error
-		await expect(client.createDocument(12345)).resolves.toBeInstanceOf(Document);
+		await expect(client.document.create(12345)).resolves.toBeInstanceOf(Document);
 
 		// @ts-expect-error
-		await expect(client.createDocument(() => {})).resolves.toBeInstanceOf(Document);
+		await expect(client.document.create(() => {})).resolves.toBeInstanceOf(Document);
 	});
 
 	it("should fail to create a document - wrong second parameter", async () => {
 		const error = new TypeError(OPTIONS_WRONG_TYPE);
 
 		// @ts-expect-error
-		await expect(client.createDocument("STRING", "")).rejects.toThrow(error);
+		await expect(client.document.create("STRING", "")).rejects.toThrow(error);
 
 		// @ts-expect-error
-		await expect(client.createDocument("ARRAY", [])).rejects.toThrow(error);
+		await expect(client.document.create("ARRAY", [])).rejects.toThrow(error);
 
 		// @ts-expect-error
-		await expect(client.createDocument("NUMBER", 12345)).rejects.toThrow(error);
+		await expect(client.document.create("NUMBER", 12345)).rejects.toThrow(error);
 
 		// @ts-expect-error
-		await expect(client.createDocument("NULL", null)).rejects.toThrow(error);
+		await expect(client.document.create("NULL", null)).rejects.toThrow(error);
 	});
 
 	it("should fail to create a document - no data", async () => {
 		// @ts-expect-error
-		await expect(client.createDocument()).rejects.toThrow(new Error(NO_TEXT));
+		await expect(client.document.create()).rejects.toThrow(new Error(NO_TEXT));
 	});
 
 	afterEach(() => {
diff --git a/src/test/deleteDocument.test.ts b/src/test/deleteDocument.test.ts
index a4acadb..476aa89 100644
--- a/src/test/deleteDocument.test.ts
+++ b/src/test/deleteDocument.test.ts
@@ -9,45 +9,45 @@ import { ID_WRONG_TYPE, NO_ID, NO_TOKEN } from "../lib/errors/Messages";
 import { IMPERIAL_TOKEN, RESPONSE } from "./common";
 const fetchMock: typeof fetchMockJest = require("node-fetch");
 
-describe("createDocument", () => {
+describe("deleteDocument", () => {
 	let client: Imperial;
 
 	beforeEach(() => {
 		client = new Imperial(IMPERIAL_TOKEN);
 
-		fetchMock.delete(`${client.rest.api}/document/${RESPONSE.document.documentId}`, {
+		fetchMock.delete(`${client.rest.api}/document/${RESPONSE.data.id}`, {
 			body: { success: true },
 			headers: { "Content-Type": "application/json" },
 		});
 	});
 
 	it("should delete a document - fully valid", async () => {
-		await client.deleteDocument(RESPONSE.document.documentId);
+		await client.document.delete(RESPONSE.data.id);
 
-		await client.deleteDocument(new URL(`https://${client.rest.hostname}/p/${RESPONSE.document.documentId}`));
+		await client.document.delete(new URL(`https://${client.rest.hostname}/p/${RESPONSE.data.id}`));
 	});
 
 	it("should fail to delete a document - no token", async () => {
 		client.setApiToken(undefined);
 
-		await expect(client.deleteDocument(RESPONSE.document.documentId)).rejects.toThrow(new Error(NO_TOKEN));
+		await expect(client.document.delete(RESPONSE.data.id)).rejects.toThrow(new Error(NO_TOKEN));
 	});
 
 	it("should fail to delete a document - wrong id type", async () => {
 		const error = new Error(ID_WRONG_TYPE);
 
-		await expect(client.deleteDocument({})).rejects.toThrow(error);
+		await expect(client.document.delete({})).rejects.toThrow(error);
 
-		await expect(client.deleteDocument([])).rejects.toThrow(error);
+		await expect(client.document.delete([])).rejects.toThrow(error);
 
-		await expect(client.deleteDocument(12345)).rejects.toThrow(error);
+		await expect(client.document.delete(12345)).rejects.toThrow(error);
 
-		await expect(client.deleteDocument(() => {})).rejects.toThrow(error);
+		await expect(client.document.delete(() => {})).rejects.toThrow(error);
 	});
 
 	it("should fail to delete a document - no id", async () => {
 		// @ts-expect-error
-		await expect(client.deleteDocument()).rejects.toThrow(new Error(NO_ID));
+		await expect(client.document.delete()).rejects.toThrow(new Error(NO_ID));
 	});
 
 	afterEach(() => {
diff --git a/src/test/editDocument.test.ts b/src/test/editDocument.test.ts
index a35a48e..09753ce 100644
--- a/src/test/editDocument.test.ts
+++ b/src/test/editDocument.test.ts
@@ -9,14 +9,14 @@ import { ID_WRONG_TYPE, NO_ID, NO_TEXT, NO_TOKEN } from "../lib/errors/Messages"
 import { IMPERIAL_TOKEN, RESPONSE } from "./common";
 const fetchMock: typeof fetchMockJest = require("node-fetch");
 
-describe("createDocument", () => {
+describe("editDocument", () => {
 	let client: Imperial;
 
 	beforeEach(() => {
 		client = new Imperial(IMPERIAL_TOKEN);
 
 		fetchMock.patch(`${client.rest.api}/document`, (_: any, req: any) => {
-			if (JSON.parse(req.body).document !== RESPONSE.document.documentId)
+			if (JSON.parse(req.body).id !== RESPONSE.data.id)
 				return {
 					body: { success: false },
 					status: 400,
@@ -30,60 +30,60 @@ describe("createDocument", () => {
 	});
 
 	it("should edit a document - fully valid", async () => {
-		await client.editDocument(RESPONSE.document.documentId, "i am a valid edit");
+		await client.document.edit(RESPONSE.data.id, "i am a valid edit");
 
-		await client.editDocument(
-			new URL(`https://${client.rest.hostname}/p/${RESPONSE.document.documentId}`),
+		await client.document.edit(
+			new URL(`https://${client.rest.hostname}/p/${RESPONSE.data.id}`),
 			"i am a valid edit",
 		);
 	});
 
 	it("should edit a document - text not a string", async () => {
 		// @ts-expect-error
-		await expect(client.editDocument(RESPONSE.document.documentId, {})).resolves.toBeInstanceOf(Document);
+		await expect(client.document.edit(RESPONSE.data.id, {})).resolves.toBeInstanceOf(Document);
 
 		// @ts-expect-error
-		await expect(client.editDocument(RESPONSE.document.documentId, [])).resolves.toBeInstanceOf(Document);
+		await expect(client.document.edit(RESPONSE.data.id, [])).resolves.toBeInstanceOf(Document);
 
 		// @ts-expect-error
-		await expect(client.editDocument(RESPONSE.document.documentId, 12345)).resolves.toBeInstanceOf(Document);
+		await expect(client.document.edit(RESPONSE.data.id, 12345)).resolves.toBeInstanceOf(Document);
 
 		// @ts-expect-error
-		await expect(client.editDocument(RESPONSE.document.documentId, () => {})).resolves.toBeInstanceOf(Document);
+		await expect(client.document.edit(RESPONSE.data.id, () => {})).resolves.toBeInstanceOf(Document);
 	});
 
 	it("should fail to edit a document - no token", async () => {
 		client.setApiToken(undefined);
 
 		await expect(async () => {
-			await client.editDocument(RESPONSE.document.documentId, "i am a valid edit");
+			await client.document.edit(RESPONSE.data.id, "i am a valid edit");
 		}).rejects.toThrow(new Error(NO_TOKEN));
 	});
 
 	it("should fail to delete a document - no id", async () => {
 		// @ts-expect-error
-		await expect(client.editDocument()).rejects.toThrow(new Error(NO_ID));
+		await expect(client.document.edit()).rejects.toThrow(new Error(NO_ID));
 	});
 
 	it("should fail to edit a document - wrong type of id", async () => {
 		const error = new Error(ID_WRONG_TYPE);
 
 		// @ts-expect-error
-		await expect(client.editDocument({})).rejects.toThrow(error);
+		await expect(client.document.edit({})).rejects.toThrow(error);
 
 		// @ts-expect-error
-		await expect(client.editDocument([])).rejects.toThrow(error);
+		await expect(client.document.edit([])).rejects.toThrow(error);
 
 		// @ts-expect-error
-		await expect(client.editDocument(12345)).rejects.toThrow(error);
+		await expect(client.document.edit(12345)).rejects.toThrow(error);
 
 		// @ts-expect-error
-		await expect(client.editDocument(() => {})).rejects.toThrow(error);
+		await expect(client.document.edit(() => {})).rejects.toThrow(error);
 	});
 
 	it("should fail to delete a document - no text", async () => {
 		// @ts-expect-error
-		await expect(client.editDocument(RESPONSE.document.documentId)).rejects.toThrow(new Error(NO_TEXT));
+		await expect(client.document.edit(RESPONSE.data.id)).rejects.toThrow(new Error(NO_TEXT));
 	});
 
 	afterEach(() => {
diff --git a/src/test/getDocument.test.ts b/src/test/getDocument.test.ts
index 87fe899..e214754 100644
--- a/src/test/getDocument.test.ts
+++ b/src/test/getDocument.test.ts
@@ -9,39 +9,39 @@ import { ID_WRONG_TYPE, NO_ID } from "../lib/errors/Messages";
 import { IMPERIAL_TOKEN, RESPONSE } from "./common";
 const fetchMock: typeof fetchMockJest = require("node-fetch");
 
-describe("createDocument", () => {
+describe("getDocument", () => {
 	let client: Imperial;
 
 	beforeEach(() => {
 		client = new Imperial(IMPERIAL_TOKEN);
 
-		fetchMock.get(`${client.rest.api}/document/${RESPONSE.document.documentId}`, {
-			body: { success: true },
+		fetchMock.get(`${client.rest.api}/document/${RESPONSE.data.id}`, {
+			body: RESPONSE,
 			headers: { "Content-Type": "application/json" },
 		});
 	});
 
 	it("should fetch a document - fully valid", async () => {
-		await client.getDocument(RESPONSE.document.documentId);
+		await client.document.get(RESPONSE.data.id);
 
-		await client.getDocument(new URL(`https://${client.rest.hostname}/p/${RESPONSE.document.documentId}`));
+		await client.document.get(new URL(`https://${client.rest.hostname}/p/${RESPONSE.data.id}`));
 	});
 
 	it("should fail to fetch a document - wrong id type", async () => {
 		const error = new Error(ID_WRONG_TYPE);
 
-		await expect(client.getDocument({})).rejects.toThrow(error);
+		await expect(client.document.get({})).rejects.toThrow(error);
 
-		await expect(client.getDocument([])).rejects.toThrow(error);
+		await expect(client.document.get([])).rejects.toThrow(error);
 
-		await expect(client.getDocument(12345)).rejects.toThrow(error);
+		await expect(client.document.get(12345)).rejects.toThrow(error);
 
-		await expect(client.getDocument(() => {})).rejects.toThrow(error);
+		await expect(client.document.get(() => {})).rejects.toThrow(error);
 	});
 
 	it("should fail to fetch a document - no id", async () => {
 		// @ts-expect-error
-		await expect(client.getDocument()).rejects.toThrow(new Error(NO_ID));
+		await expect(client.document.get()).rejects.toThrow(new Error(NO_ID));
 	});
 
 	afterEach(() => {
diff --git a/src/test/purgeDocuments.test.ts b/src/test/purgeDocuments.test.ts
index f126ee0..fb64569 100644
--- a/src/test/purgeDocuments.test.ts
+++ b/src/test/purgeDocuments.test.ts
@@ -10,7 +10,7 @@ const fetchMock: typeof fetchMockJest = require("node-fetch");
 
 const numberDeleted = 420;
 
-describe("createDocument", () => {
+describe("purgeDocument", () => {
 	let client: Imperial;
 
 	beforeEach(() => {
@@ -26,15 +26,17 @@ describe("createDocument", () => {
 		});
 	});
 
-	it("should purge document - valid", async () => {
+	it.skip("should purge document - valid", async () => {
+		// @ts-ignore
 		const response = await client.purgeDocuments();
 
 		expect(response.numberDeleted).toBe(numberDeleted);
 	});
 
-	it("should not purge document - no token", async () => {
+	it.skip("should not purge document - no token", async () => {
 		client.setApiToken();
 
+		// @ts-ignore
 		await expect(client.purgeDocuments()).rejects.toThrowError(new Error(NO_TOKEN));
 	});