Filter object properties (keys) keeping typings

I'm trying to build a function to filter (include | exclude) an object properties.
JS Function is working fine but I can't figure out how to type it correctly.
Here's what I've attempted so far:

// filter object keys
export const filterObjKeys = <T extends {}, K extends keyof T>(
  obj: T,
  includeKeys: K[] = [],
  excludeKeys: K[] = [],
): T => {
  return Object.fromEntries(
    Object.entries(obj).filter(([k, v]) =>
      includeKeys?.length > 0 ? includeKeys.includes(k) : !excludeKeys.includes(k),
    ),
  ) as Omit<T, typeof excludeKeys>;
};

This is my desired result (it works but types on results are wrong, they remain the same of the complete interface):

interface Student {
  firtsName: string;
  lastName: string;
  email: string;
  class: number;
}

const student: Student = {
  firtsName: 'John',
  lastName: 'Doe',
  email: 'a@b.com',
  class: 3,
};

const filteredStudentInc = filterObjKeys(student, ['firtsName', 'lastName']);
// {firtsName: 'John', lastName: 'Doe'}

const filteredStudentExc = filterObjKeys(student, [], ['email'])
// {firtsName: 'John', lastName: 'Doe', class: 3}

First of all, let's update our constraints.
T extends {} doesn't mean that T is a non-primitive type. The correct option would be object:

// true
type Case1 = number extends {} ? true : false
// false
type Case2 = number extends object ? true : false

For the keys probably you will need only string keys, thus let's extract only string keys by either intersecting keyof T & string or using Extract Extract<keyof T, string>

Now, let's implement the pickObjKeys:

export const pickObjKeys = <T extends object, K extends keyof T & string>(
  obj: T,
  keys: K[],
): Pick<T, K> => {
  return Object.fromEntries(keys.map((key) => [key, obj[key]])) as Pick<T, K>;
};

I've simplified the implementation's logic, now instead of Object.entries we generate entries using Array.prototype.map over the passed keys. Note that unfortunately, there will be no way to make the whole implementation fully type-safe, thus we will need to use assertion to get rid of the error. To actually pick the fields we use the built-in Pick utility type.

Testing:

// const filteredStudentInc: Pick<Student, "firtsName" | "lastName">
const filteredStudentInc = pickObjKeys(student, ['firtsName', 'lastName']);

It looks correct, but if we want to see how the type exactly looks we will need some utility that will make the result types more readable:

Prettify - Accepts a type and returns its simplified version for better readability. Transforms interface to type, simplifies intersections

type Prettify<T> = T extends infer R
  ? {
      [K in keyof R]: R[K];
    }
  : never;

Prettify works because we redeclare the type and remap its fields, which results in more literal types.

Testing:

const pickObjKeys = <T extends object, K extends keyof T & string>(
  obj: T,
  keys: K[],
): Prettify<Pick<T, K>> => {
  return Object.fromEntries(keys.map((key) => [key, obj[key]])) as Prettify<
    Pick<T, K>
  >;
};

// const filteredStudentInc: {
//   firtsName: string;
//   lastName: string;
// }
const filteredStudentInc = pickObjKeys(student, ['firtsName', 'lastName']);

Now, let's jump to the excludeObjKeys:

const excludeObjKeys = <T extends object, K extends keyof T & string>(
  obj: T,
  keys: K[],
): Prettify<Omit<T, K>> => {
  return Object.fromEntries(
    Object.keys(obj).reduce<[string, unknown][]>((acc, key) => {
      if (!keys.includes(key as K)) acc.push([key, obj[key as K]]);

      return acc;
    }, []),
  ) as Prettify<Omit<T, K>>;
};

The logic here is a bit more complex, however, I've tried to optimize it as I could. We get the keys using Object.keys and using Array.prototype.reduce() we both generate entries and filter out excluded properties. And to remove the properties from the type we need the built-in Omit utility type.

Testing:

// const filteredStudentExc: {
//   firtsName: string;
//   lastName: string;
// }
const filteredStudentExc = excludeObjKeys(student, ['email', 'class']);

playground