Store/Import Typing Updates (#388)

* optional target for send

* guard store options

packages/api/src/record.ts

@@ -377,8 +377,7 @@ export class Record implements RecordModel {
     return this._agent.processDwnRequest(request);
   }
 
-
-  async store(options: any = {}): Promise<any> {
+  async _processRecord(options: { store: boolean, import: boolean }): Promise<any> {
 
     const { store = true, import: _import = false } = options;
 
@@ -432,35 +431,40 @@ export class Record implements RecordModel {
 
   }
 
-  async import(options?: any): Promise<any> {
+  async store(options?: { import: boolean }): Promise<any> {
+    return this._processRecord({ ...options, store: true });
+  }
+
+  async import(options?: { store: boolean }): Promise<any> {
     // Add check to bail if already imported
-    return this.store({ store: options?.store !== false, import: true });
+    return this._processRecord({ store: options?.store !== false, import: true });
   }
 
+
+
   /**
    * Send the current record to a remote DWN by specifying their DID
+   * If no DID is specified, the target is assumed to be the owner (connectedDID).
    * (vs waiting for the regular DWN sync)
-   * @param target - the DID to send the record to
+   * @param target - the optional DID to send the record to, if none is set it is sent to the connectedDid
    * @returns the status of the send record request
    * @throws `Error` if the record has already been deleted.
    *
    * @beta
    */
-  async send(_options?: string | { [key: string]: any }): Promise<ResponseStatus> {
+  async send(target?: string): Promise<ResponseStatus> {
 
     const initialWrite = this._initialWrite;
-    const options = !_options ? { target: this._connectedDid } : typeof _options === 'string' ? { target: _options } : _options;
-
-    if (!options.target){
-      options.target = this._connectedDid;
+    if (!target) {
+      target = this._connectedDid;
     }
 
-    if (initialWrite && !Record.checkSendCache(this._recordId, options.target)){
+    if (initialWrite && !Record.checkSendCache(this._recordId, target)){
 
       const initialState = {
         messageType : DwnInterfaceName.Records + DwnMethodName.Write,
         author      : this._connectedDid,
-        target      : options.target,
+        target      : target,
         rawMessage  : removeUndefinedProperties({
           contextId: this._contextId,
           ...initialWrite
@@ -469,15 +473,15 @@ export class Record implements RecordModel {
 
       await this._agent.sendDwnRequest(initialState);
 
-      Record.setSendCache(this._recordId, options.target);
+      Record.setSendCache(this._recordId, target);
 
     }
 
     const latestState = {
       messageType : DwnInterfaceName.Records + DwnMethodName.Write,
       author      : this._connectedDid,
       dataStream  : await this.data.blob(),
-      target      : options.target
+      target      : target
     } as any;
 
     if (this._authorization) {