@ember-data/model 5.4.0-alpha.32 → 5.4.0-alpha.34

package/unstable-preview-types/-private/errors.d.ts

@@ -1,306 +1,308 @@
-/// <reference types="ember-source/types" />
-/// <reference types="ember-source/types" />
-import { type NativeArray } from '@ember/array';
-import ArrayProxy from '@ember/array/proxy';
-import type RecordState from './record-state';
-type ValidationError = {
-    attribute: string;
-    message: string;
-};
-/**
-  @module @ember-data/model
-*/
-interface ArrayProxyWithCustomOverrides<T> extends Omit<ArrayProxy<T>, 'clear' | 'content'> {
-    content: NativeArray<T>;
-    clear(): void;
-    _has(name: string): boolean;
-}
-declare const ArrayProxyWithCustomOverrides: new <T>() => ArrayProxyWithCustomOverrides<T>;
-/**
-  Holds validation errors for a given record, organized by attribute names.
-
-  This class is not directly instantiable.
-
-  Every `Model` has an `errors` property that is an instance of
-  `Errors`. This can be used to display validation error
-  messages returned from the server when a `record.save()` rejects.
-
-  For Example, if you had a `User` model that looked like this:
-
-  ```app/models/user.js
-  import Model, { attr } from '@ember-data/model';
-
-  export default class UserModel extends Model {
-    @attr('string') username;
-    @attr('string') email;
+declare module '@ember-data/model/-private/errors' {
+  /// <reference types="ember-source/types" />
+  /// <reference types="ember-source/types" />
+  import { type NativeArray } from '@ember/array';
+  import ArrayProxy from '@ember/array/proxy';
+  import type RecordState from '@ember-data/model/-private/record-state';
+  type ValidationError = {
+      attribute: string;
+      message: string;
+  };
+  /**
+    @module @ember-data/model
+  */
+  interface ArrayProxyWithCustomOverrides<T> extends Omit<ArrayProxy<T>, 'clear' | 'content'> {
+      content: NativeArray<T>;
+      clear(): void;
+      _has(name: string): boolean;
   }
-  ```
-  And you attempted to save a record that did not validate on the backend:
-
-  ```javascript
-  let user = store.createRecord('user', {
-    username: 'tomster',
-    email: 'invalidEmail'
-  });
-  user.save();
-  ```
-
-  Your backend would be expected to return an error response that described
-  the problem, so that error messages can be generated on the app.
-
-  API responses will be translated into instances of `Errors` differently,
-  depending on the specific combination of adapter and serializer used. You
-  may want to check the documentation or the source code of the libraries
-  that you are using, to know how they expect errors to be communicated.
-
-  Errors can be displayed to the user by accessing their property name
-  to get an array of all the error objects for that property. Each
-  error object is a JavaScript object with two keys:
-
-  - `message` A string containing the error message from the backend
-  - `attribute` The name of the property associated with this error message
-
-  ```handlebars
-  <label>Username: <Input @value={{@model.username}} /> </label>
-  {{#each @model.errors.username as |error|}}
-    <div class="error">
-      {{error.message}}
-    </div>
-  {{/each}}
-
-  <label>Email: <Input @value={{@model.email}} /> </label>
-  {{#each @model.errors.email as |error|}}
-    <div class="error">
-      {{error.message}}
-    </div>
-  {{/each}}
-  ```
-
-  You can also access the special `messages` property on the error
-  object to get an array of all the error strings.
-
-  ```handlebars
-  {{#each @model.errors.messages as |message|}}
-    <div class="error">
-      {{message}}
-    </div>
-  {{/each}}
-  ```
-
-  @class Errors
-  @public
-  @extends Ember.ArrayProxy
- */
-declare class Errors extends ArrayProxyWithCustomOverrides<ValidationError> {
-    __record: {
-        currentState: RecordState;
-    };
-    /**
-      @property errorsByAttributeName
-      @type {MapWithDefault}
-      @private
-    */
-    get errorsByAttributeName(): Map<string, NativeArray<ValidationError>>;
-    /**
-      Returns errors for a given attribute
-  
-      ```javascript
-      let user = store.createRecord('user', {
-        username: 'tomster',
-        email: 'invalidEmail'
-      });
-      user.save().catch(function(){
-        user.errors.errorsFor('email'); // returns:
-        // [{attribute: "email", message: "Doesn't look like a valid email."}]
-      });
-      ```
-  
-      @method errorsFor
-      @public
-      @param {String} attribute
-      @return {Array}
-    */
-    errorsFor(attribute: string): NativeArray<ValidationError>;
-    /**
-      An array containing all of the error messages for this
-      record. This is useful for displaying all errors to the user.
-  
-      ```handlebars
-      {{#each @model.errors.messages as |message|}}
-        <div class="error">
-          {{message}}
-        </div>
-      {{/each}}
-      ```
-  
-      @property messages
-      @public
-      @type {Array}
-    */
-    messages: string[];
-    /**
-      @property content
-      @type {Array}
-      @private
-    */
-    get content(): NativeArray<ValidationError>;
-    /**
-      @method unknownProperty
-      @private
-    */
-    unknownProperty(attribute: string): NativeArray<ValidationError> | undefined;
-    /**
-      Total number of errors.
-  
-      @property length
-      @type {Number}
-      @public
-      @readOnly
-    */
-    /**
-      `true` if we have no errors.
-  
-      @property isEmpty
-      @type {Boolean}
-      @public
-      @readOnly
-    */
-    isEmpty: boolean;
-    /**
-     Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on
-      the record and transition the record into an `invalid` state.
+  declare const ArrayProxyWithCustomOverrides: new <T>() => ArrayProxyWithCustomOverrides<T>;
+  /**
+    Holds validation errors for a given record, organized by attribute names.
   
-     Example
-     ```javascript
-      let errors = user.errors;
+    This class is not directly instantiable.
   
-      // add multiple errors
-      errors.add('password', [
-        'Must be at least 12 characters',
-        'Must contain at least one symbol',
-        'Cannot contain your name'
-      ]);
+    Every `Model` has an `errors` property that is an instance of
+    `Errors`. This can be used to display validation error
+    messages returned from the server when a `record.save()` rejects.
   
-      errors.errorsFor('password');
-      // =>
-      // [
-      //   { attribute: 'password', message: 'Must be at least 12 characters' },
-      //   { attribute: 'password', message: 'Must contain at least one symbol' },
-      //   { attribute: 'password', message: 'Cannot contain your name' },
-      // ]
+    For Example, if you had a `User` model that looked like this:
   
-      // add a single error
-      errors.add('username', 'This field is required');
+    ```app/models/user.js
+    import Model, { attr } from '@ember-data/model';
   
-      errors.errorsFor('username');
-      // =>
-      // [
-      //   { attribute: 'username', message: 'This field is required' },
-      // ]
-     ```
-      @method add
-      @public
-      @param {string} attribute - the property name of an attribute or relationship
-      @param {string[]|string} messages - an error message or array of error messages for the attribute
-     */
-    add(attribute: string, messages: string[] | string): void;
-    /**
-      @method _findOrCreateMessages
-      @private
-    */
-    _findOrCreateMessages(attribute: string, messages: string | string[]): ValidationError[];
-    /**
-     Manually removes all errors for a given member from the record.
-       This will transition the record into a `valid` state, and
-      triggers the `becameValid` event and lifecycle method.
+    export default class UserModel extends Model {
+      @attr('string') username;
+      @attr('string') email;
+    }
+    ```
+    And you attempted to save a record that did not validate on the backend:
   
-     Example:
+    ```javascript
+    let user = store.createRecord('user', {
+      username: 'tomster',
+      email: 'invalidEmail'
+    });
+    user.save();
+    ```
   
-     ```javascript
-      let errors = user.errors;
-      errors.add('phone', ['error-1', 'error-2']);
+    Your backend would be expected to return an error response that described
+    the problem, so that error messages can be generated on the app.
   
-      errors.errorsFor('phone');
-      // =>
-      // [
-      //   { attribute: 'phone', message: 'error-1' },
-      //   { attribute: 'phone', message: 'error-2' },
-      // ]
+    API responses will be translated into instances of `Errors` differently,
+    depending on the specific combination of adapter and serializer used. You
+    may want to check the documentation or the source code of the libraries
+    that you are using, to know how they expect errors to be communicated.
   
-      errors.remove('phone');
+    Errors can be displayed to the user by accessing their property name
+    to get an array of all the error objects for that property. Each
+    error object is a JavaScript object with two keys:
   
-      errors.errorsFor('phone');
-      // => undefined
-     ```
-     @method remove
-      @public
-     @param {string} member - the property name of an attribute or relationship
-     */
-    remove(attribute: string): void;
-    /**
-     Manually clears all errors for the record.
-       This will transition the record into a `valid` state, and
-       will trigger the `becameValid` event and lifecycle method.
+    - `message` A string containing the error message from the backend
+    - `attribute` The name of the property associated with this error message
   
-    Example:
+    ```handlebars
+    <label>Username: <Input @value={{@model.username}} /> </label>
+    {{#each @model.errors.username as |error|}}
+      <div class="error">
+        {{error.message}}
+      </div>
+    {{/each}}
   
-     ```javascript
-     let errors = user.errors;
-     errors.add('username', ['error-a']);
-     errors.add('phone', ['error-1', 'error-2']);
+    <label>Email: <Input @value={{@model.email}} /> </label>
+    {{#each @model.errors.email as |error|}}
+      <div class="error">
+        {{error.message}}
+      </div>
+    {{/each}}
+    ```
   
-     errors.errorsFor('username');
-     // =>
-     // [
-     //   { attribute: 'username', message: 'error-a' },
-     // ]
+    You can also access the special `messages` property on the error
+    object to get an array of all the error strings.
   
-     errors.errorsFor('phone');
-     // =>
-     // [
-     //   { attribute: 'phone', message: 'error-1' },
-     //   { attribute: 'phone', message: 'error-2' },
-     // ]
+    ```handlebars
+    {{#each @model.errors.messages as |message|}}
+      <div class="error">
+        {{message}}
+      </div>
+    {{/each}}
+    ```
   
-     errors.clear();
-  
-     errors.errorsFor('username');
-     // => undefined
-  
-     errors.errorsFor('phone');
-     // => undefined
-  
-     errors.messages
-     // => []
-     ```
-     @method clear
-     @public
-     */
-    clear(): void;
-    /**
-      Checks if there are error messages for the given attribute.
-  
-      ```app/controllers/user/edit.js
-      import Controller from '@ember/controller';
-      import { action } from '@ember/object';
-  
-      export default class UserEditController extends Controller {
-        @action
-        save(user) {
-          if (user.errors.has('email')) {
-            return alert('Please update your email before attempting to save.');
+    @class Errors
+    @public
+    @extends Ember.ArrayProxy
+   */
+  declare class Errors extends ArrayProxyWithCustomOverrides<ValidationError> {
+      __record: {
+          currentState: RecordState;
+      };
+      /**
+        @property errorsByAttributeName
+        @type {MapWithDefault}
+        @private
+      */
+      get errorsByAttributeName(): Map<string, NativeArray<ValidationError>>;
+      /**
+        Returns errors for a given attribute
+    
+        ```javascript
+        let user = store.createRecord('user', {
+          username: 'tomster',
+          email: 'invalidEmail'
+        });
+        user.save().catch(function(){
+          user.errors.errorsFor('email'); // returns:
+          // [{attribute: "email", message: "Doesn't look like a valid email."}]
+        });
+        ```
+    
+        @method errorsFor
+        @public
+        @param {String} attribute
+        @return {Array}
+      */
+      errorsFor(attribute: string): NativeArray<ValidationError>;
+      /**
+        An array containing all of the error messages for this
+        record. This is useful for displaying all errors to the user.
+    
+        ```handlebars
+        {{#each @model.errors.messages as |message|}}
+          <div class="error">
+            {{message}}
+          </div>
+        {{/each}}
+        ```
+    
+        @property messages
+        @public
+        @type {Array}
+      */
+      messages: string[];
+      /**
+        @property content
+        @type {Array}
+        @private
+      */
+      get content(): NativeArray<ValidationError>;
+      /**
+        @method unknownProperty
+        @private
+      */
+      unknownProperty(attribute: string): NativeArray<ValidationError> | undefined;
+      /**
+        Total number of errors.
+    
+        @property length
+        @type {Number}
+        @public
+        @readOnly
+      */
+      /**
+        `true` if we have no errors.
+    
+        @property isEmpty
+        @type {Boolean}
+        @public
+        @readOnly
+      */
+      isEmpty: boolean;
+      /**
+       Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on
+        the record and transition the record into an `invalid` state.
+    
+       Example
+       ```javascript
+        let errors = user.errors;
+    
+        // add multiple errors
+        errors.add('password', [
+          'Must be at least 12 characters',
+          'Must contain at least one symbol',
+          'Cannot contain your name'
+        ]);
+    
+        errors.errorsFor('password');
+        // =>
+        // [
+        //   { attribute: 'password', message: 'Must be at least 12 characters' },
+        //   { attribute: 'password', message: 'Must contain at least one symbol' },
+        //   { attribute: 'password', message: 'Cannot contain your name' },
+        // ]
+    
+        // add a single error
+        errors.add('username', 'This field is required');
+    
+        errors.errorsFor('username');
+        // =>
+        // [
+        //   { attribute: 'username', message: 'This field is required' },
+        // ]
+       ```
+        @method add
+        @public
+        @param {string} attribute - the property name of an attribute or relationship
+        @param {string[]|string} messages - an error message or array of error messages for the attribute
+       */
+      add(attribute: string, messages: string[] | string): void;
+      /**
+        @method _findOrCreateMessages
+        @private
+      */
+      _findOrCreateMessages(attribute: string, messages: string | string[]): ValidationError[];
+      /**
+       Manually removes all errors for a given member from the record.
+         This will transition the record into a `valid` state, and
+        triggers the `becameValid` event and lifecycle method.
+    
+       Example:
+    
+       ```javascript
+        let errors = user.errors;
+        errors.add('phone', ['error-1', 'error-2']);
+    
+        errors.errorsFor('phone');
+        // =>
+        // [
+        //   { attribute: 'phone', message: 'error-1' },
+        //   { attribute: 'phone', message: 'error-2' },
+        // ]
+    
+        errors.remove('phone');
+    
+        errors.errorsFor('phone');
+        // => undefined
+       ```
+       @method remove
+        @public
+       @param {string} member - the property name of an attribute or relationship
+       */
+      remove(attribute: string): void;
+      /**
+       Manually clears all errors for the record.
+         This will transition the record into a `valid` state, and
+         will trigger the `becameValid` event and lifecycle method.
+    
+      Example:
+    
+       ```javascript
+       let errors = user.errors;
+       errors.add('username', ['error-a']);
+       errors.add('phone', ['error-1', 'error-2']);
+    
+       errors.errorsFor('username');
+       // =>
+       // [
+       //   { attribute: 'username', message: 'error-a' },
+       // ]
+    
+       errors.errorsFor('phone');
+       // =>
+       // [
+       //   { attribute: 'phone', message: 'error-1' },
+       //   { attribute: 'phone', message: 'error-2' },
+       // ]
+    
+       errors.clear();
+    
+       errors.errorsFor('username');
+       // => undefined
+    
+       errors.errorsFor('phone');
+       // => undefined
+    
+       errors.messages
+       // => []
+       ```
+       @method clear
+       @public
+       */
+      clear(): void;
+      /**
+        Checks if there are error messages for the given attribute.
+    
+        ```app/controllers/user/edit.js
+        import Controller from '@ember/controller';
+        import { action } from '@ember/object';
+    
+        export default class UserEditController extends Controller {
+          @action
+          save(user) {
+            if (user.errors.has('email')) {
+              return alert('Please update your email before attempting to save.');
+            }
+            user.save();
           }
-          user.save();
         }
-      }
-      ```
-  
-      @method has
-      @public
-      @param {String} attribute
-      @return {Boolean} true if there some errors on given attribute
-    */
-    has(attribute: string): boolean;
+        ```
+    
+        @method has
+        @public
+        @param {String} attribute
+        @return {Boolean} true if there some errors on given attribute
+      */
+      has(attribute: string): boolean;
+  }
+  export default Errors;
 }
-export default Errors;
 //# sourceMappingURL=errors.d.ts.map