Expose "objectId" in Importable References
Hi. I opened this issue last week, but after some messaging, I thought I could't explain my problem properly, and closed it myself to avoid misleading in development. Now I'm trying my best to explain the problem. Here is my case:

I create a `login-form` symbol in my `Library B` using `input-default` symbol from `Library A`. 

On an instance of `login-form` in `Library B`, i override `input-default` symbols with `input-error` symbol from `Library A`. Then I save the override values (`Input-Symbol-Id-1`) to `login-form symbol's master` as error-state.

Later in my `Project Document`, I import `login-form` from `Library B` to present the login-form's default and error states. To present eror state, I don't override the input fields manually again, just load the previously saved `error-state`.

So, I get the saved override value from login-form symbol (which is `Input-Symbol-Id-1` for `Library B`), look for that `Input-Symbol-Id-1` in importable references of potential libraries, and import if found. 

The problem is; `id`s in importable references are unique for every document, which they become `symbolId` when imported. There is no way to search importable references by neither `Library B`'s `symbolId` nor `Library A`'s `symbolId`. Because of there is no `objectId` exposed in importable references, the only way to find it as an importable reference is search it by importable's `name`, which may not be unique.

Here you can see my example code:

```js
const getValueForSymbolOverride = (doc, symbol, override) => {
  // Look for overriding symbol master in this document.
  let master = doc.getSymbolMasterWithID(override.value)
  // If master is in this document return symbolId.
  if (master) {
    return master.symbolId
  }
  // If overriding symbol master not in this document,
  // then look in symbol master's library's importable references.
  let library = symbol.master.getLibrary()
  if (library) {
    let importable = library.getImportableSymbolReferencesForDocument(doc)
      .find(importable => importable.id == override.value)
      // If overriding symbol master's reference found in
      // symbol master's library, import it and return symbolId.
    if (importable) {
      return importable.import().symbolId
    }
    // If overriding symbol master's reference not found in symbol master's
    // library too, lets try to find it as an object to get more info about it.
    master = library.getDocument().getSymbols()
      .find(master => master.symbolId == override.value)
    if (master) {
      // Ok, we found local overriding master in symbol master's library.
      // We know its objectID and name now.
      // Is that master imported to that library from another too?
      if (master.getLibrary()) {
        // Then lets try to find it in its own library.
        // Here we can search by name only! Because importable references
        // has no objectId and reference's id is useless for our search.
        importable = master.getLibrary()
          .getImportableSymbolReferencesForDocument(doc)
          .find(importable => importable.name == master.name)
      } else {
        // So, overriding symbol master is not imported to library from
        // another. It is an original symbol of the library which we imported
        // to document from. Lets try to find it as an importable.
        importable = library.getImportableSymbolReferencesForDocument(doc)
          .find(importable => importable.name == master.name)
      }
      // If overriding symbol found, import it and return symbolId.
      if (importable) {
        return importable.import().symbolId
      }
    }
  }
}
```

The situation is same for Text Styles and Layer Styles.

I'm using this code in my [Symbol States](https://github.com/ozgurgunes/Sketch-Symbol-States) plugin. It will be more stable if `objectId`s exposed in importable references.