code: function getUnionSignatures(types, kind) {
              var signatureLists = ts.map(types, function (t) { return getSignaturesOfType(t, kind); });
              var result = undefined;
              for (var i = 0; i < signatureLists.length; i++) {
                  for (var _i = 0, _a = signatureLists[i]; _i < _a.length; _i++) {
                      var signature = _a[_i];
                      // Only process signatures with parameter lists that aren't already in the result list
                      if (!result || !findMatchingSignature(result, signature, /*partialMatch*/ false, /*ignoreThisTypes*/ true, /*ignoreReturnTypes*/ true)) {
                          var unionSignatures = findMatchingSignatures(signatureLists, signature, i);
                          if (unionSignatures) {
                              var s = signature;
                              // Union the result types when more than one signature matches
                              if (unionSignatures.length > 1) {
                                  s = cloneSignature(signature);
                                  if (ts.forEach(unionSignatures, function (sig) { return sig.thisParameter; })) {
                                      var thisType = getUnionType(ts.map(unionSignatures, function (sig) { return getTypeOfSymbol(sig.thisParameter) || anyType; }), /*subtypeReduction*/ true);
                                      s.thisParameter = createTransientSymbol(signature.thisParameter, thisType);
                                  }
                                  // Clear resolved return type we possibly got from cloneSignature
                                  s.resolvedReturnType = undefined;
                                  s.unionSignatures = unionSignatures;
                              }
                              (result || (result = [])).push(s);
                          }
                      }
                  }
              }
              return result || emptyArray;
          }
docs: The signatures of a union type are those signatures that are present in each of the constituent types. Generic signatures must match exactly, but non-generic signatures are allowed to have extra optional parameters and may differ in return types. When signatures differ in return types, the resulting return type is the union of the constituent return types.