Merge pull request #114 from AlbertLochmueller/patch-1

Small language correction :)

Author: RobinBuschmann

README.md

@@ -61,8 +61,8 @@ class Person extends Model<Person> {
   hobbies: Hobby[];
 }
 ```
-The model needs to extend the `Model` class and has to be annotated with the `@Table` decorator. All properties, that
-should appear as a column in the database, require the `@Column` annotation.
+The model needs to extend the `Model` class and has to be annotated with the `@Table` decorator. All properties that
+should appear as a column in the database require the `@Column` annotation.
 
 ### `@Table`
 The `@Table` annotation can be used without passing any parameters. To specify some more define options, use
@@ -111,7 +111,7 @@ Decorator          | Description
  `@DeletedAt`      | sets `timestamps=true`, `paranoid=true` and `deletedAt='deletionDate'`
 
 ### `@Column`
-The `@Column` annotation can be used without passing any parameters. But therefore it is necessary, that
+The `@Column` annotation can be used without passing any parameters. But therefore it is necessary that
 the js type can be inferred automatically (see [Type inference](#type-inference) for details).
 ```typescript
   @Column
@@ -201,8 +201,8 @@ const sequelize =  new Sequelize({
         modelPaths: [__dirname + '/models']
 });
 ```
-Before you can use your models, you have to tell sequelize where they can be found. So either set `modelPaths` in the 
-sequlize config or add the required models later on by calling `sequelize.addModels([Person])` or 
+Before you can use your models you have to tell sequelize where they can be found. So either set `modelPaths` in the 
+sequelize config or add the required models later on by calling `sequelize.addModels([Person])` or 
 `sequelize.addModels([__dirname + '/models'])`:
 
 ```typescript
@@ -233,7 +233,7 @@ person.save();
 ```
 
 ### Find and update
-Finding and updating entries do also work like using native sequelize. So see sequelize 
+Finding and updating entries does also work like using native sequelize. So see sequelize 
 [docs](http://docs.sequelizejs.com/manual/tutorial/models-usage.html) for more details.
 ```typescript
 Person
@@ -340,7 +340,7 @@ Decorator                                 | Description
  `@BelongsTo(relatedModelGetter: () => typeof Model, options: AssociationOptionsBelongsTo)` | sets `SourceModel.belongsTo(RelatedModel, ...)` while `as` is key of annotated property and `options` are additional association options 
  `@HasMany(relatedModelGetter: () => typeof Model)` | sets `SourceModel.hasMany(RelatedModel, ...)` while `as` is key of annotated property and `foreignKey` is resolved from target related class
  `@HasMany(relatedModelGetter: () => typeof Model, foreignKey: string)` | sets `SourceModel.hasMany(RelatedModel, ...)` while `as` is key of annotated property and `foreignKey` is explicitly specified value
- `@HasMany(relatedModelGetter: () => typeof Model, options: AssociationOptionsHasMany)` | sets `SourceModel.hasMany(RelatedModel, ...)` while `as` is key of annotated property and `options` are additional association otions
+ `@HasMany(relatedModelGetter: () => typeof Model, options: AssociationOptionsHasMany)` | sets `SourceModel.hasMany(RelatedModel, ...)` while `as` is key of annotated property and `options` are additional association options
  `@HasOne(relatedModelGetter: () => typeof Model)` | sets `SourceModel.hasOne(RelatedModel, ...)` while `as` is key of annotated property and `foreignKey` is resolved from target related class
  `@HasOne(relatedModelGetter: () => typeof Model, foreignKey: string)` | sets `SourceModel.hasOne(RelatedModel, ...)` while `as` is key of annotated property and `foreignKey` is explicitly specified value
  `@HasOne(relatedModelGetter: () => typeof Model, options: AssociationOptionsHasOne)` | sets `SourceModel.hasOne(RelatedModel, ...)` while `as` is key of annotated property and `options` are additional association options
@@ -350,7 +350,7 @@ Decorator                                 | Description
  `@BelongsToMany(relatedModelGetter: () => typeof Model, through: string, foreignKey: string, otherKey: string)` | sets `SourceModel.belongsToMany(RelatedModel, {through: throughString, ...})` while `as` is key of annotated property and `foreignKey`/`otherKey` are explicitly specified values
  `@BelongsToMany(relatedModelGetter: () => typeof Model, through: string, options: AssociationOptionsBelongsToMany)` | sets `SourceModel.belongsToMany(RelatedModel, {through: throughString, ...})` while `as` is key of annotated property and `options` are additional association values, including `foreignKey` and `otherKey`.
 
- Note that when using AssociationOptions, certain properties will be overwritten when the association is built based on reflection metadata or explicit attribute parameters. For example, `as` will always be the annotated property's name, and `through` will be the explicitly stated value.
+Note that when using AssociationOptions, certain properties will be overwritten when the association is built, based on reflection metadata or explicit attribute parameters. For example, `as` will always be the annotated property's name, and `through` will be the explicitly stated value.
 
 ### Multiple relations of same models
 *sequelize-typescript* resolves the foreign keys by identifying the corresponding class references.
@@ -407,7 +407,7 @@ explicitly:
 With the creation of a relation, sequelize generates some method on the corresponding
 models. So when you create a 1:n relation between `ModelA` and `ModelB`, an instance of `ModelA` will
 have the functions `getModelBs`, `setModelBs`, `addModelB`, `removeModelB`, `hasModelB`. These functions still exist with *sequelize-typescript*. 
-But TypeScript will not know of them and in turn will complain, when you try to access `getModelB`, `setModelB` or 
+But TypeScript wont recognize them and will complain if you try to access `getModelB`, `setModelB` or 
 `addModelB`. To make TypeScript happy, the `Model.prototype` of *sequelize-typescript* has `$set`, `$get`, `$add` 
 functions. 
 ```typescript
@@ -425,7 +425,7 @@ class ModelB extends Model<ModelB> {
   a: ModelA;
 }
 ```
-To use them pass the property key of the respective relation as the first parameter:
+To use them, pass the property key of the respective relation as the first parameter:
 ```typescript
 const modelA = new ModelA();
 
@@ -442,7 +442,7 @@ modelA.$create('bs', /* value */ ).then( /* ... */);
 Validation options can be set through the `@Column` annotation, but if you prefer to use separate decorators for 
 validation instead, you can do so by simply adding the validate options *as* decorators:
 So that `validate.isEmail=true` becomes `@IsEmail`, `validate.equals='value'` becomes `@Equals('value')` 
-and so on. Please notice, that a validator, that expects a boolean, is translated to an annotation without a parameter. 
+and so on. Please notice that a validator that expects a boolean is translated to an annotation without a parameter. 
 
 See sequelize [docs](http://docs.sequelizejs.com/manual/tutorial/models-definition.html#validations) 
 for all validators.
@@ -511,8 +511,8 @@ export class Shoe extends Model<Shoe> {
 ```
 
 ## Scopes
-Scopes can be defined with annotations as well. The scope options are mostly the same like in native
-sequelize except of the way how model classes are referenced. So instead of referencing them directly a getter
+Scopes can be defined with annotations as well. The scope options are mostly identical to native
+sequelize except for the way model classes are referenced. So instead of referencing them directly a getter
 function `() => Model` is used instead. 
 (See sequelize [docs](http://docs.sequelizejs.com/manual/tutorial/scopes.html) for more details)
 
@@ -593,7 +593,7 @@ You cannot add one and the same model to multiple Sequelize instances with
 differently configured connections. So that one model will only work for one connection.
 ### One model class per file
 This is not only good practice regarding design, but also matters for the order
-of execution. Since typescript creates a `__metadata("design:type", SomeModel)` call due to `emitDecoratorMetadata` 
+of execution. Since Typescript creates a `__metadata("design:type", SomeModel)` call due to `emitDecoratorMetadata` 
 compile option, in some cases `SomeModel` is probably not defined(not undefined!) and would throw a `ReferenceError`.
 When putting `SomeModel` in a separate file, it would look like `__metadata("design:type", SomeModel_1.SomeModel)`,
 which does not throw an error.
@@ -625,4 +625,4 @@ npm package maintainers to maintain their own typings, but Microsoft still has d
 accepting PR's and keeping quality high.
 
 **Keep in mind `sequelize-typescript` does not provide typings for `sequelize`** - these are seperate things.
-A lot of the types in `sequelize-typescript` augment, refer to, or extends what sequelize already has.
+A lot of the types in `sequelize-typescript` augment, refer to, or extend what sequelize already has.