diff --git a/compat/src/index.d.ts b/compat/src/index.d.ts
index 9405f7d99a..504ca40d53 100644
--- a/compat/src/index.d.ts
+++ b/compat/src/index.d.ts
@@ -83,10 +83,13 @@ declare namespace React {
 		isPureReactComponent: boolean;
 	}
 
-	export function memo<P = {}>(
-		component: preact.FunctionalComponent<P>,
-		comparer?: (prev: P, next: P) => boolean
-	): preact.FunctionComponent<P>;
+	export function memo<C extends preact.FunctionalComponent<any>>(
+		component: C,
+		comparer?: (
+			prev: preact.ComponentProps<C>,
+			next: preact.ComponentProps<C>
+		) => boolean
+	): C;
 
 	export interface ForwardFn<P = {}, T = any> {
 		(props: P, ref: Ref<T>): preact.ComponentChild;
diff --git a/compat/test/ts/memo.tsx b/compat/test/ts/memo.tsx
new file mode 100644
index 0000000000..a6bbbb8d91
--- /dev/null
+++ b/compat/test/ts/memo.tsx
@@ -0,0 +1,40 @@
+import * as React from '../../src';
+
+function ExpectType<T>(v: T) {} // type assertion helper
+
+interface MemoProps {
+	required: string;
+	optional?: string;
+	defaulted: string;
+}
+
+const ReadonlyBaseComponent = (props: Readonly<MemoProps>) => (
+	<div>{props.required + props.optional + props.defaulted}</div>
+);
+ReadonlyBaseComponent.defaultProps = { defaulted: '' };
+
+const BaseComponent = (props: MemoProps) => (
+	<div>{props.required + props.optional + props.defaulted}</div>
+);
+BaseComponent.defaultProps = { defaulted: '' };
+
+// memo for readonly component with default comparison
+const MemoedReadonlyComponent = React.memo(ReadonlyBaseComponent);
+ExpectType<React.FunctionComponent<MemoProps>>(MemoedReadonlyComponent);
+export const memoedReadonlyComponent = (
+	<MemoedReadonlyComponent required="hi" />
+);
+
+// memo for non-readonly component with default comparison
+const MemoedComponent = React.memo(BaseComponent);
+ExpectType<React.FunctionComponent<MemoProps>>(MemoedComponent);
+export const memoedComponent = <MemoedComponent required="hi" />;
+
+// memo with custom comparison
+const CustomMemoedComponent = React.memo(BaseComponent, (a, b) => {
+	ExpectType<MemoProps>(a);
+	ExpectType<MemoProps>(b);
+	return a.required === b.required;
+});
+ExpectType<React.FunctionComponent<MemoProps>>(CustomMemoedComponent);
+export const customMemoedComponent = <CustomMemoedComponent required="hi" />;
diff --git a/src/index.d.ts b/src/index.d.ts
index 5d3807d2cd..8cfc68a836 100644
--- a/src/index.d.ts
+++ b/src/index.d.ts
@@ -69,13 +69,18 @@ declare namespace preact {
 		};
 	}
 
-	type RenderableProps<P, RefType = any> = Readonly<
-		P & Attributes & { children?: ComponentChildren; ref?: Ref<RefType> }
-	>;
+	type RenderableProps<P, RefType = any> = P &
+		Readonly<Attributes & { children?: ComponentChildren; ref?: Ref<RefType> }>;
 
 	type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
 	type ComponentFactory<P = {}> = ComponentType<P>;
 
+	type ComponentProps<C extends ComponentType<any>> = C extends ComponentType<
+		infer P
+	>
+		? P
+		: never;
+
 	interface FunctionComponent<P = {}> {
 		(props: RenderableProps<P>, context?: any): VNode<any> | null;
 		displayName?: string;