How to use the jsii-reflect.InterfaceType function in jsii-reflect

return isConstruct(typeOrTypeRef.mapOfType);
    }

    if (typeOrTypeRef.unionOfTypes) {
      return typeOrTypeRef.unionOfTypes.some(x => isConstruct(x));
    }

    if (typeOrTypeRef.type) {
      type = typeOrTypeRef.type;
    } else {
      return false;
    }
  }

  // if it is an interface, it should extend cdk.IConstruct
  if (type instanceof jsiiReflect.InterfaceType) {
    const constructIface = type.system.findFqn('@aws-cdk/core.IConstruct');
    return type.extends(constructIface);
  }

  // if it is a class, it should extend cdk.Construct
  if (type instanceof jsiiReflect.ClassType) {
    const constructClass = type.system.findFqn('@aws-cdk/core.Construct');
    return type.extends(constructClass);
  }

  return false;
}

function dispatch(apiElement: ApiElement, fns: {
  method(m: reflect.Method): T;
  init(m: reflect.Initializer): T;
  property(m: reflect.Property): T;
  enumMember(m: reflect.EnumMember): T;
  enumType(m: reflect.EnumType): T;
  klass(m: reflect.ClassType): T;
  iface(m: reflect.InterfaceType): T;
}) {

  if (apiElement instanceof reflect.Method) { return fns.method(apiElement); }
  if (apiElement instanceof reflect.Property) { return fns.property(apiElement); }
  if (apiElement instanceof reflect.EnumMember) { return fns.enumMember(apiElement); }
  if (apiElement instanceof reflect.ClassType) { return fns.klass(apiElement); }
  if (apiElement instanceof reflect.InterfaceType) { return fns.iface(apiElement); }
  if (apiElement instanceof reflect.Initializer) { return fns.init(apiElement); }
  if (apiElement instanceof reflect.EnumType) { return fns.enumType(apiElement); }

  throw new Error(`Unrecognized violator: ${apiElement}`);
}

const t = documentable.docs.customTag(tag);
  if (t) { return t; }

  if ((documentable instanceof reflect.Property || documentable instanceof reflect.Method) && documentable.overrides) {
    if (documentable.overrides.isClassType() || documentable.overrides.isInterfaceType()) {
      const baseMembers = documentable.overrides.allMembers.filter(m => m.name === documentable.name);
      for (const base of baseMembers) {
        const baseTag = getDocTag(base, tag);
        if (baseTag) {
          return baseTag;
        }
      }
    }
  }

  if (documentable instanceof reflect.ClassType || documentable instanceof reflect.InterfaceType) {
    for (const base of documentable.interfaces) {
      const baseTag = getDocTag(base, tag);
      if (baseTag) {
         return baseTag;
      }
    }
  }

  if (documentable instanceof reflect.ClassType && documentable.base) {
    const baseTag = getDocTag(documentable.base, tag);
    if (baseTag) {
      return baseTag;
    }
  }

  return undefined;

export function isDataType(t: jsiiReflect.Type | undefined): t is jsiiReflect.InterfaceType {
  if (!t) {
    return false;
  }
  return t instanceof jsiiReflect.InterfaceType && (t as any).spec.datatype;
}