declare module '@ember/debug/data-adapter' {
    import type Owner from "@ember/owner";
    import type { NativeArray } from "@ember/array";
    import EmberObject from "@ember/object";
    import type ContainerDebugAdapter from "@ember/debug/container-debug-adapter";
    /**
    @module @ember/debug/data-adapter
    */
    type RecordColor = "black" | "red" | "blue" | "green";
    type Column = {
        name: string;
        desc: string;
    };
    type WrappedType<N extends string = string> = {
        name: N;
        count: number;
        columns: Column[];
        object: unknown;
    };
    type WrappedRecord<T> = {
        object: T;
        columnValues: object;
        searchKeywords: NativeArray<unknown>;
        filterValues: object;
        color: RecordColor | null;
    };
    type RecordCallback<T> = (records: Array<{
        columnValues: object;
        object: T;
    }>) => void;
    /**
      The `DataAdapter` helps a data persistence library
      interface with tools that debug Ember such
      as the [Ember Inspector](https://github.com/emberjs/ember-inspector)
      for Chrome and Firefox.

      This class will be extended by a persistence library
      which will override some of the methods with
      library-specific code.

      The methods likely to be overridden are:

      * `getFilters`
      * `detect`
      * `columnsForType`
      * `getRecords`
      * `getRecordColumnValues`
      * `getRecordKeywords`
      * `getRecordFilterValues`
      * `getRecordColor`

      The adapter will need to be registered
      in the application's container as `dataAdapter:main`.

      Example:

      ```javascript
      Application.initializer({
        name: "data-adapter",

        initialize: function(application) {
          application.register('data-adapter:main', DS.DataAdapter);
        }
      });
      ```

      @class DataAdapter
      @extends EmberObject
      @public
    */
    export default class DataAdapter<T> extends EmberObject {
        releaseMethods: NativeArray<() => void>;
        recordsWatchers: Map<unknown, {
            release: () => void;
            revalidate: () => void;
        }>;
        typeWatchers: Map<unknown, {
            release: () => void;
            revalidate: () => void;
        }>;
        flushWatchers: (() => void) | null;
        containerDebugAdapter: ContainerDebugAdapter;
        constructor(owner: Owner);
        /**
          The container-debug-adapter which is used
          to list all models.
      
          @property containerDebugAdapter
          @default undefined
          @since 1.5.0
          @public
        **/
        /**
          The number of attributes to send
          as columns. (Enough to make the record
          identifiable).
      
          @private
          @property attributeLimit
          @default 3
          @since 1.3.0
        */
        attributeLimit: number;
        /**
           Ember Data > v1.0.0-beta.18
           requires string model names to be passed
           around instead of the actual factories.
      
           This is a stamp for the Ember Inspector
           to differentiate between the versions
           to be able to support older versions too.
      
           @public
           @property acceptsModelName
         */
        acceptsModelName: boolean;
        /**
           Map from records arrays to RecordsWatcher instances
      
           @private
           @property recordsWatchers
           @since 3.26.0
         */
        /**
          Map from records arrays to TypeWatcher instances
      
          @private
          @property typeWatchers
          @since 3.26.0
         */
        /**
          Callback that is currently scheduled on backburner end to flush and check
          all active watchers.
      
          @private
          @property flushWatchers
          @since 3.26.0
      
         */
        /**
          Stores all methods that clear observers.
          These methods will be called on destruction.
      
          @private
          @property releaseMethods
          @since 1.3.0
        */
        /**
          Specifies how records can be filtered.
          Records returned will need to have a `filterValues`
          property with a key for every name in the returned array.
      
          @public
          @method getFilters
          @return {Array} List of objects defining filters.
           The object should have a `name` and `desc` property.
        */
        getFilters(): Array<{
            name: string;
            desc: string;
        }>;
        /**
          Fetch the model types and observe them for changes.
      
          @public
          @method watchModelTypes
      
          @param {Function} typesAdded Callback to call to add types.
          Takes an array of objects containing wrapped types (returned from `wrapModelType`).
      
          @param {Function} typesUpdated Callback to call when a type has changed.
          Takes an array of objects containing wrapped types.
      
          @return {Function} Method to call to remove all observers
        */
        watchModelTypes(typesAdded: (types: WrappedType[]) => void, typesUpdated: (types: WrappedType[]) => void): () => void;
        _nameToClass(type: unknown): unknown;
        /**
          Fetch the records of a given type and observe them for changes.
      
          @public
          @method watchRecords
      
          @param {String} modelName The model name.
      
          @param {Function} recordsAdded Callback to call to add records.
          Takes an array of objects containing wrapped records.
          The object should have the following properties:
            columnValues: {Object} The key and value of a table cell.
            object: {Object} The actual record object.
      
          @param {Function} recordsUpdated Callback to call when a record has changed.
          Takes an array of objects containing wrapped records.
      
          @param {Function} recordsRemoved Callback to call when a record has removed.
          Takes an array of objects containing wrapped records.
      
          @return {Function} Method to call to remove all observers.
        */
        watchRecords(modelName: string, recordsAdded: RecordCallback<T>, recordsUpdated: RecordCallback<T>, recordsRemoved: RecordCallback<T>): () => void;
        updateFlushWatchers(): void;
        /**
          Clear all observers before destruction
          @private
          @method willDestroy
        */
        willDestroy(): void;
        /**
          Detect whether a class is a model.
      
          Test that against the model class
          of your persistence library.
      
          @public
          @method detect
          @return boolean Whether the class is a model class or not.
        */
        detect(_klass: unknown): boolean;
        /**
          Get the columns for a given model type.
      
          @public
          @method columnsForType
          @return {Array} An array of columns of the following format:
           name: {String} The name of the column.
           desc: {String} Humanized description (what would show in a table column name).
        */
        columnsForType(_klass: unknown): Column[];
        /**
          Adds observers to a model type class.
      
          @private
          @method observeModelType
          @param {String} modelName The model type name.
          @param {Function} typesUpdated Called when a type is modified.
          @return {Function} The function to call to remove observers.
        */
        observeModelType(modelName: string, typesUpdated: (types: WrappedType[]) => void): () => void;
        /**
          Wraps a given model type and observes changes to it.
      
          @private
          @method wrapModelType
          @param {Class} klass A model class.
          @param {String} modelName Name of the class.
          @return {Object} The wrapped type has the following format:
            name: {String} The name of the type.
            count: {Integer} The number of records available.
            columns: {Columns} An array of columns to describe the record.
            object: {Class} The actual Model type class.
        */
        wrapModelType<N extends string>(klass: unknown, name: N): WrappedType<N>;
        /**
          Fetches all models defined in the application.
      
          @private
          @method getModelTypes
          @return {Array} Array of model types.
        */
        getModelTypes(): Array<{
            klass: unknown;
            name: string;
        }>;
        /**
          Loops over all namespaces and all objects
          attached to them.
      
          @private
          @method _getObjectsOnNamespaces
          @return {Array} Array of model type strings.
        */
        _getObjectsOnNamespaces(): string[];
        /**
          Fetches all loaded records for a given type.
      
          @public
          @method getRecords
          @return {Array} An array of records.
           This array will be observed for changes,
           so it should update when new records are added/removed.
        */
        getRecords(_klass: unknown, _name: string): NativeArray<T>;
        /**
          Wraps a record and observers changes to it.
      
          @private
          @method wrapRecord
          @param {Object} record The record instance.
          @return {Object} The wrapped record. Format:
          columnValues: {Array}
          searchKeywords: {Array}
        */
        wrapRecord(record: T): WrappedRecord<T>;
        /**
          Gets the values for each column.
      
          @public
          @method getRecordColumnValues
          @return {Object} Keys should match column names defined
          by the model type.
        */
        getRecordColumnValues(_record: T): {};
        /**
          Returns keywords to match when searching records.
      
          @public
          @method getRecordKeywords
          @return {Array} Relevant keywords for search.
        */
        getRecordKeywords(_record: T): NativeArray<unknown>;
        /**
          Returns the values of filters defined by `getFilters`.
      
          @public
          @method getRecordFilterValues
          @param {Object} record The record instance.
          @return {Object} The filter values.
        */
        getRecordFilterValues(_record: T): object;
        /**
          Each record can have a color that represents its state.
      
          @public
          @method getRecordColor
          @param {Object} record The record instance
          @return {String} The records color.
            Possible options: black, red, blue, green.
        */
        getRecordColor(_record: T): RecordColor | null;
    }
    export {};
}