ongoose.model(collectionName, mongooseSchema) });
  }
});
```
3) Would you please shorten your question?
<issue_comment>username_3: Thanks!
Your correctly implemented method made it work better for me.
Now I can have another static function which has access to this.fixed.refs. If I'd used mongoose it could look like this (simplified):

    const DbClient = stampit().static({
      use(collectionName, mongooseSchema) {
        return this.refs({ db: mongoose.model(collectionName, mongooseSchema) });
      },
      remove(id) {
        this.fixed.refs.db.remove(id)
      }
    });

Would this be an ok way to reach db from within another static function?
<issue_comment>username_0: Avoid using static functions @username_3. Use regular stamps for do everything. This "remove" function looks misplaced and redundant as to my taste.

The sole idea of stampit is to be able to compose any behavior. Utilize "stampit().methods()" as much as you can. Answering your qestion: no, it is not.
<issue_comment>username_4: Hey guys, I'm trying to use Stamps to build my Angular views and having trouble figuring out how to structure my objects.  I'm trying to achieve the following:

1. Expose primitive properties for 2-way binding
2. Attach methods for meta-data and some actions
3. Return only the primitive properties when it's time to send to the server

Here's a very simple example of what I'm trying to convert to stamps:

```js
$scope.customer = {
  // These capitalized properties are what the server cares about.
  // They are 2-way bound to the UI.
  // Eg. <input ng-model="customer.FirstName"... />
  FirstName: null,
  LastName: null,
  State: null,

  // A list of States needs to be available for a dropdown in the UI.  
  // The user selects from this list to fill in the State property above.
  // I don't want this property to be sent to the server.   
  stateOptions: ['AL', 'NY', 'OH',...],

  // Customer information is edited in a modal dialog.  
  // There are other modals in the same view, so I want to be able to compose customizable modal methods.
  
  // Bound to the view to indicate where or not the modal is shown
  // Eg. <customer-details-modal show="customer.showModal">...</customer-details-modal>
  showModal: false,

  showModal: function() {    
    // TODO: Need to store the current "state" of the property values in case the user cancels and we need to revert
    this.showModal = true;
  },

  modalSaved: function() {
    // TODO: Send data to the server.
    // Payload should be only this:
    // {
    //   FirstName: 'Bob',
    //   LastName: null,
    //   State: 'AL'
    // }

    // customerApi.save(/* what goes here? */)
  },
  modalCancelled: function() {
    // TODO: Revert any changes made 
  }
};
```

Possible stamps:

```js
var Customer = {
}

$scope.customer = {
  // These capitalized properties are what the server cares about.
  // They are 2-way bound to the UI.
  // Eg. <input ng-model="customer.FirstName"... />
  

  // A list of States needs to be available for a dropdown in the UI.  
  // The user selects from this list to fill in the State property above.
  // I don't want this property to be sent to the server.   
  stateOptions: ['AL', 'NY', 'OH',...],

  // Customer information is edited in a modal dialog.  
  // There are other modals in the same view, so I want to be able to compose customizable modal methods.
  
  // Bound to the view to indicate where or not the modal is shown
  // Eg. <customer-details-modal show="customer.showModal">...</customer-details-modal>
  showModal: false,

  showModal: function() {    
    // TODO: Need to store the current "state" of the property values in case the user cancels and we need to revert
    this.showModal = true;
  },

  modalSaved: function() {
    // TODO: Send data to the server.
    // Payload should be only this:
    // {
    //   FirstName: 'Bob',
    //   LastName: null,
    //   State: 'AL'
    // }

    // customerApi.save(/* what goes here? */)
  },
  modalCancelled: function() {
    // TODO: Revert any changes made 
  }
};
```
<issue_comment>username_4: Hey guys, I'm trying to use Stamps to build my Angular views and having trouble figuring out how to structure my objects.  I'll list out as much detail as I can, hopefully you can provide some direction if you have the time.  If not, no worries.

Here's a very simple example of what I'm trying to convert to stamps:

```js
$scope.customer = {
  // These capitalized properties are what the server cares about.
  // They are 2-way bound to the UI.
  // Eg. <input ng-model="customer.FirstName"... />
  FirstName: null,
  LastName: null,
  State: null,

  // A list of States needs to be available for a dropdown in the UI.  
  // The user selects from this list to fill in the State property above.
  // I don't want this property to be sent to the server.   
  stateOptions: ['AL', 'NY', 'OH',...],

  // Customer information is edited in a modal dialog.   
  // This is bound to the DOM to indicate where or not the modal is shown
  // Eg. <customer-details-modal show="customer.showModal">...</customer-details-modal>
  showModal: false,

  showModal: function() {    
    // TODO: Need to store the current "state" of the property values in case the user cancels and we need to revert
    this.showModal = true;
  },

  modalSaved: function() {
    // TODO: Send data to the server.
    // Payload should be only this:
    // {
    //   FirstName: 'Bob',
    //   LastName: null,
    //   State: 'AL'
    // }

    // customerApi.save(/* what goes here? */)
  },
  modalCancelled: function() {
    // TODO: Revert any changes made 
  }
};
```

I'm trying to achieve the following:

1. Expose primitive properties for 2-way binding in the DOM
2. Attach methods for meta-data (eg. list of states) and some actions (eg. show/hide editing form modal)
3. Retrieve only the primitive properties when it's time to send to the server

Possible stamps (not sure if I'm structuring these correctly):

```js

// There are other modals in the same page, so I want to be able to compose customizable modal methods.
var Modal = stampit()
 .init(function() {
    this.shown = false;
  })
 .methods({
    show: function() {
      this.shown = true;
    },
    ok: function() { ...  },
    cancel: function() { ...   }
  });

var Customer = stampit()
 .props({
    FirstName: null,
    LastName: null,
    State: null
  });

var CustomerView = stampit()
 .methods({
    sendToApi: function() { 
      // This is the part I'm really hoping for an elegant solution to     
    },
    showEditModal: function() {
      // @username_1 has mentioned his namespaces his Stamps, how is that done?
      // can I do something like this to avoid generic "show" properties on every object?
      // this.modal.show();
     }
   })
 .compose(Modal, Customer);

$scope.customer = CustomerView({ stateOptions: ['AL', 'NY', 'OH',...] });

// As I mentioned earlier, there are other objects on the same page I need to handle in very similar ways.  For example:

$scope.