/**
*  @license
* Copyright 2021, JsData. All rights reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.

* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* ==========================================================================
*/
import { Scikit1D, Scikit2D, Tensor2D } from '../types';
import { TransformerMixin } from '../mixins';
export interface OrdinalEncoderParams {
    /**
     * Categories (unique values) per feature:
     * ‘auto’ : Determine categories automatically from the training data.
     * list : categories[i] holds the categories expected in the ith column.
     * The passed categories should not mix strings and numeric values, and should be sorted in case of numeric values.
     * **default = "auto"**
     */
    categories?: 'auto' | (number | string | boolean)[][];
    /** When set to ‘error’ an error will be raised in case an unknown categorical
     * feature is present during transform. When set to ‘use_encoded_value’,
     * the encoded value of unknown categories will be set to the value
     * given for the parameter unknown_value.
     * In inverse_transform, an unknown category will be denoted as null.
     * **default = "error"**
     */
    handleUnknown?: 'error' | 'useEncodedValue';
    /**When the parameter handle_unknown is set to ‘use_encoded_value’, this parameter
     * is required and will set the encoded value of unknown categories.
     * It has to be distinct from the values used to encode any of the categories in fit.
     * Great choices for this number are NaN or -1. **default = NaN** */
    unknownValue?: number;
}
/**
 * Encode categorical features as an integer array.
 * The input to this transformer should be an array-like of integers or strings,
 * which represent categorical (discrete) features. The features are then converted to ordinal integers.

* @example
 * ```js
 *  const X = [
      ['Male', 1],
      ['Female', 2],
      ['Male', 4]
    ]
    const encode = new OrdinalEncoder()
    encode.fitTransform(X) // returns the expected object below
    const expected = [
      [0, 0],
      [1, 1],
      [0, 2]
    ]
 * ```
 */
export declare class OrdinalEncoder extends TransformerMixin {
    categories: (number | string | boolean)[][];
    handleUnknown?: 'error' | 'useEncodedValue';
    unknownValue?: number;
    /** This holds the categories parameter that is passed in the constructor. `this.categories`
     * holds the actual learned categories or the ones passed in from the constructor */
    categoriesParam: 'auto' | (number | string | boolean)[][];
    /** The number of features seen during fit */
    nFeaturesIn: number;
    /** Names of features seen during fit. Only stores feature names if input is a DataFrame */
    featureNamesIn: Array<string>;
    /** Useful for pipelines and column transformers to have a default name for transforms */
    name: string;
    constructor({ categories, handleUnknown, unknownValue }?: OrdinalEncoderParams);
    classesToMapping(classes: Array<string | number | boolean>): Map<string | number | boolean, number>;
    loopOver2DArrayToSetLabels(array2D: any): void;
    /**
     * Fits a OrdinalEncoder to the data.
     */
    fit(X: Scikit2D, y?: Scikit1D): OrdinalEncoder;
    loopOver2DArrayToUseLabels(array2D: any): (number | undefined)[][];
    /**
     * Encodes the data using the fitted OrdinalEncoder.
     */
    transform(X: Scikit2D, y?: Scikit1D): Tensor2D;
}