Typescript 从其他两个泛型创建泛型

我试图使用两个泛型

DeepMerge

和

confirt

创建一个

confirteddeepmerge

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends (infer U)[]
    ? DeepPartial<U>[]
    : T[P] extends ReadonlyArray<infer U>
      ? ReadonlyArray<DeepPartial<U>>
      : DeepPartial<T[P]>
};

type ConfineExtention<A, B> = { [K in keyof B]: K extends keyof A ? (DeepPartial<A>[K]) : never };
type Confine<A, B extends ConfineExtention<A, B>> = B;

type DeepMerge<T, U> = [T, U] extends [object, object] ?
  {
    [K in keyof (U & Pick<T, Exclude<keyof T, keyof U>>)]: (
      K extends keyof U ? (
        K extends keyof T ? DeepMerge<T[K], U[K]> : U[K]
      ) : (
        K extends keyof T ? T[K] : never
      )
    )
  } : U;

type ConfineDeepMerge<A, B> = Confine<A, DeepMerge<A, B>>;

类型DeepPartial={
[P在keyof T中]？：T[P]扩展（推断U）[]
？深度部分[]
：T[P]扩展只读数组
？只读阵列
：深偏
};
类型限制扩展

类型“DeepMerge”不满足约束“受限扩展>”。
类型“B{[K in keyof（B&Pick>）]：K extends keyof B？K extends keyof A DeepMerge:B[K]：K extends keyof A[K]：never；}”不可分配给类型“限制扩展>”。
类型“B”不可分配给类型“限制扩展>”。[2344]

如何合并这两个泛型？
我正在尝试找出您想要的。。。谁知道呢，也许是这样：

type ConfineMerge<T, C extends {
  [K in keyof C]: K extends keyof T ? (Partial<T>[K]) : never
}> = Pick<T, Exclude<keyof T, keyof C>> & C;

类型：合并=Pick&C；

如果你能编辑这个问题来解释你想做什么，那会很有帮助
 这是可行的，但非常冗长：

type Merge<M, N> = Omit<M, Extract<keyof M, keyof N>> & N;
// type Confine<A, B extends { [K in keyof B]: K extends keyof A ? A[K] : never }> = B;
type ConfineMerge<T, C extends ExtentionForConfineMerge<T, C>> = Pick<T, Exclude<keyof T, keyof C>> & C;
type ExtentionForConfineMerge<T, C> = {[K in keyof C]: K extends keyof T ? (Partial<T>[K]) : never};

export interface Discover <
Raw,
RawOverrides extends ExtentionForConfineMerge<Raw, RawOverrides>,
Proto extends ExtentionForConfineMerge<Merge<Raw, RawOverrides>, Proto>,
ProtoOverrides extends ExtentionForConfineMerge<Merge<Merge<Raw, RawOverrides>, Proto>, ProtoOverrides>,
> {
  Raw: Raw;
  RawOverrides: ConfineMerge<Raw, RawOverrides>;
  Proto: ConfineMerge<Merge<Raw, RawOverrides>, Proto>;
  ProtoOverrides: ConfineMerge<Merge<Merge<Raw, RawOverrides>, Proto>, ProtoOverrides>;
}

类型合并=省略&N；
//类型限制=B；
类型：合并=拾取&C；
类型extensionforconfinetmerge={[K in keyof C]：K扩展keyof T？（部分[K]）：never}；
导出接口发现<
未经加工的
RawOverrides扩展了ExtensionForConstrictMerge，
Proto将扩展扩展扩展为限制合并，
ProtoOverrides扩展了ExtensionForLimitMerge，
> {
生的：生的；
RAW覆盖：限制合并；
原型：合并；
协议覆盖：限制合并；
}
是的，这个问题需要进一步澄清。有没有办法使用这两个泛型来形成第三个？我更新了它以反映最近的问题。还是在想办法把这些东西连接起来。