declare module '@ember-data/adapter/error' {
  export default AdapterError;
  export class InvalidError {
      private constructor();
      code: string;
  }
  export class TimeoutError {
      private constructor();
      code: string;
  }
  export class AbortError {
      private constructor();
      code: string;
  }
  export class UnauthorizedError {
      private constructor();
      code: string;
  }
  export class ForbiddenError {
      private constructor();
      code: string;
  }
  export class NotFoundError {
      private constructor();
      code: string;
  }
  export class ConflictError {
      private constructor();
      code: string;
  }
  export class ServerError {
      private constructor();
      code: string;
  }
  const AdapterError: typeof _AdapterError;
  /**
    ## Overview
  
    <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
    <p>
      ⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
      If starting a new app or thinking of implementing a new adapter, consider writing a
      <a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
    </p>
    </blockquote>
  
    An `AdapterError` is used by an adapter to signal that an error occurred
    during a request to an external API. It indicates a generic error, and
    subclasses are used to indicate specific error states.
  
    To create a custom error to signal a specific error state in communicating
    with an external API, extend the `AdapterError`. For example, if the
    external API exclusively used HTTP `503 Service Unavailable` to indicate
    it was closed for maintenance:
  
    ```js [app/adapters/maintenance-error.js]
    import AdapterError from '@ember-data/adapter/error';
  
    export default AdapterError.extend({ message: "Down for maintenance." });
    ```
  
    This error would then be returned by an adapter's `handleResponse` method:
  
    ```js [app/adapters/application.js]
    import JSONAPIAdapter from '@ember-data/adapter/json-api';
    import MaintenanceError from './maintenance-error';
  
    export default class ApplicationAdapter extends JSONAPIAdapter {
      handleResponse(status) {
        if (503 === status) {
          return new MaintenanceError();
        }
  
        return super.handleResponse(...arguments);
      }
    }
    ```
  
    And can then be detected in an application and used to send the user to an
    `under-maintenance` route:
  
    ```js [app/routes/application.js]
    import MaintenanceError from '../adapters/maintenance-error';
  
    export default class ApplicationRoute extends Route {
      actions: {
        error(error, transition) {
          if (error instanceof MaintenanceError) {
            this.transitionTo('under-maintenance');
            return;
          }
  
          // ...other error handling logic
        }
      }
    }
    ```
  
    @class AdapterError
    @public
  */
  function _AdapterError(errors: any, message?: string): void;
  class _AdapterError {
      /**
        ## Overview
      
        <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
        <p>
          ⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
          If starting a new app or thinking of implementing a new adapter, consider writing a
          <a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
        </p>
        </blockquote>
      
        An `AdapterError` is used by an adapter to signal that an error occurred
        during a request to an external API. It indicates a generic error, and
        subclasses are used to indicate specific error states.
      
        To create a custom error to signal a specific error state in communicating
        with an external API, extend the `AdapterError`. For example, if the
        external API exclusively used HTTP `503 Service Unavailable` to indicate
        it was closed for maintenance:
      
        ```js [app/adapters/maintenance-error.js]
        import AdapterError from '@ember-data/adapter/error';
      
        export default AdapterError.extend({ message: "Down for maintenance." });
        ```
      
        This error would then be returned by an adapter's `handleResponse` method:
      
        ```js [app/adapters/application.js]
        import JSONAPIAdapter from '@ember-data/adapter/json-api';
        import MaintenanceError from './maintenance-error';
      
        export default class ApplicationAdapter extends JSONAPIAdapter {
          handleResponse(status) {
            if (503 === status) {
              return new MaintenanceError();
            }
      
            return super.handleResponse(...arguments);
          }
        }
        ```
      
        And can then be detected in an application and used to send the user to an
        `under-maintenance` route:
      
        ```js [app/routes/application.js]
        import MaintenanceError from '../adapters/maintenance-error';
      
        export default class ApplicationRoute extends Route {
          actions: {
            error(error, transition) {
              if (error instanceof MaintenanceError) {
                this.transitionTo('under-maintenance');
                return;
              }
      
              // ...other error handling logic
            }
          }
        }
        ```
      
        @class AdapterError
        @public
      */
      constructor(errors: any, message?: string);
      isAdapterError: boolean;
      stack: string | undefined;
      description: any;
      fileName: any;
      lineNumber: any;
      message: string | undefined;
      name: string | undefined;
      number: any;
      errors: any;
      code: string;
  }
  namespace _AdapterError {
      function extend({ message: defaultMessage }?: {}): {
          (errors: any, message: any): void;
          prototype: any;
          extend: ({ message: defaultMessage }?: {}) => /*elided*/ any;
      };
  }
}
//# sourceMappingURL=error.d.ts.map