diff --git a/src/exports-symbol-tree.ts b/src/exports-symbol-tree.ts
index 34dd656..19199a4 100644
--- a/src/exports-symbol-tree.ts
+++ b/src/exports-symbol-tree.ts
@@ -58,12 +58,13 @@ export class ExportsSymbolTree {
 	}
 
 	private computeTreeForChildren(targetSymbolsSet: Set<ts.Symbol>, node: ts.Node, visitedSymbols: Set<ts.Symbol>): void {
+		const typeChecker = this.program.getTypeChecker();
+
 		// it's similar to handling ts.Block node - both Block and variable's initializer are part of _implementation_
 		// and we don't care about that implementation at all - we just only need to worry it's definition
 		// for functions it is arguments and return type
 		// for variables - the type of a variable
 		if (ts.isVariableDeclaration(node)) {
-			const typeChecker = this.program.getTypeChecker();
 			const variableType = typeChecker.getTypeAtLocation(node);
 			const variableTypeSymbol = variableType.getSymbol();
 			if (variableTypeSymbol !== undefined) {
@@ -73,6 +74,15 @@ export class ExportsSymbolTree {
 			return;
 		}
 
+		if ((ts.isMethodDeclaration(node) || ts.isFunctionDeclaration(node)) && node.type === undefined) {
+			// this means that a function/method doesn't have a declared returned type so here we need to get calculated one
+			for (const signature of typeChecker.getTypeAtLocation(node).getCallSignatures()) {
+				for (const childSymbol of splitTransientSymbol(signature.getReturnType().symbol, typeChecker)) {
+					targetSymbolsSet.add(childSymbol);
+				}
+			}
+		}
+
 		ts.forEachChild(node, (childNode: ts.Node) => this.computeTreeForNode(targetSymbolsSet, childNode, visitedSymbols));
 	}
 
diff --git a/src/transformer.ts b/src/transformer.ts
index ba7132f..1756059 100644
--- a/src/transformer.ts
+++ b/src/transformer.ts
@@ -437,10 +437,19 @@ function createTransformerFactory(program: ts.Program, options?: Partial<RenameO
 			}
 
 			if (exportsSymbolTree.isSymbolAccessibleFromExports(nodeSymbol)) {
-				return putToCache(nodeSymbol, VisibilityType.External)
+				return putToCache(nodeSymbol, VisibilityType.External);
 			}
 
 			for (const declaration of symbolDeclarations) {
+				if (ts.isObjectLiteralExpression(declaration.parent)) {
+					// most likely this is unnamed object/type
+					// and the best we can do is try to find a symbol for this type in publicly accessible symbols
+					const typeSymbol = typeChecker.getTypeAtLocation(declaration.parent).symbol;
+					if (exportsSymbolTree.isSymbolAccessibleFromExports(typeSymbol)) {
+						return putToCache(nodeSymbol, VisibilityType.External)
+					}
+				}
+
 				if (!isNodeNamedDeclaration(declaration.parent) || declaration.parent.name === undefined) {
 					continue;
 				}
diff --git a/tests/test-cases/returned-untyped-object-from-exports/input.ts b/tests/test-cases/returned-untyped-object-from-exports/input.ts
new file mode 100644
index 0000000..95696f0
--- /dev/null
+++ b/tests/test-cases/returned-untyped-object-from-exports/input.ts
@@ -0,0 +1,59 @@
+class UnexportedClass {
+	public method() {
+		return { a: 123, b: 321 };
+	}
+}
+
+function privateFunctionWithDeclaredType1(): { a: number; b: string } {
+	const { a } = new UnexportedClass().method();
+	return {
+		a,
+		b: 'str',
+	};
+}
+
+function privateFunctionWithUndeclaredType() {
+	return {
+		f: 1,
+		f2: 2,
+	};
+}
+
+function privateFunctionWithDeclaredType2(): { f: number, f2: number } {
+	// note that if you extract returned value to a variable it won't work
+	return {
+		f: 1,
+		f2: 2,
+	};
+}
+
+function privateFunctionWhichUsesPublic(): void {
+	console.log(fn().a, fn1().f, fn2().f2);
+}
+
+export class ExportedClass {
+	public method() {
+		return { a: 123, b: 321 };
+	}
+
+	private privateMethod() {
+		return { a: 123, b: 321 };
+	}
+}
+
+export function fn() {
+	const { a } = privateFunctionWithDeclaredType1();
+
+	return {
+		a,
+		b: 'str',
+	};
+}
+
+export function fn1() {
+	return privateFunctionWithUndeclaredType();
+}
+
+export function fn2() {
+	return privateFunctionWithDeclaredType2();
+}
diff --git a/tests/test-cases/returned-untyped-object-from-exports/output.js b/tests/test-cases/returned-untyped-object-from-exports/output.js
new file mode 100644
index 0000000..746a687
--- /dev/null
+++ b/tests/test-cases/returned-untyped-object-from-exports/output.js
@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fn2 = exports.fn1 = exports.fn = exports.ExportedClass = void 0;
+var UnexportedClass = /** @class */ (function () {
+    function UnexportedClass() {
+    }
+    UnexportedClass.prototype._internal_method = function () {
+        return { _internal_a: 123, _internal_b: 321 };
+    };
+    return UnexportedClass;
+}());
+function privateFunctionWithDeclaredType1() {
+    var a = new UnexportedClass()._internal_method()._internal_a;
+    return {
+        _internal_a: a,
+        _internal_b: 'str',
+    };
+}
+function privateFunctionWithUndeclaredType() {
+    return {
+        f: 1,
+        f2: 2,
+    };
+}
+function privateFunctionWithDeclaredType2() {
+    // note that if you extract returned value to a variable it won't work
+    return {
+        f: 1,
+        f2: 2,
+    };
+}
+function privateFunctionWhichUsesPublic() {
+    console.log(fn().a, fn1().f, fn2().f2);
+}
+var ExportedClass = /** @class */ (function () {
+    function ExportedClass() {
+    }
+    ExportedClass.prototype.method = function () {
+        return { a: 123, b: 321 };
+    };
+    ExportedClass.prototype._private_privateMethod = function () {
+        return { _internal_a: 123, _internal_b: 321 };
+    };
+    return ExportedClass;
+}());
+exports.ExportedClass = ExportedClass;
+function fn() {
+    var a = privateFunctionWithDeclaredType1()._internal_a;
+    return {
+        a: a,
+        b: 'str',
+    };
+}
+exports.fn = fn;
+function fn1() {
+    return privateFunctionWithUndeclaredType();
+}
+exports.fn1 = fn1;
+function fn2() {
+    return privateFunctionWithDeclaredType2();
+}
+exports.fn2 = fn2;