@ohos-ports/nodejs-polars 0.22.2-beta.0

package/bin/series/index.d.ts

@@ -0,0 +1,1116 @@
+import { DataFrame } from "../dataframe";
+import { type Bool, DataType, type DTypeToJs, type DTypeToJsLoose, type DtypeToJsName, type JsToDtype, type JsType, type Optional } from "../datatypes";
+import type { Arithmetic, Comparison, Cumulative, Deserialize, EwmOps, Rolling, Round, Sample, Serialize } from "../shared_traits";
+import type { InterpolationMethod, RankMethod } from "../types";
+import { SeriesDateFunctions } from "./datetime";
+import { SeriesListFunctions } from "./list";
+import { SeriesStringFunctions } from "./string";
+import { SeriesStructFunctions } from "./struct";
+export type { SeriesDateFunctions as DatetimeSeries } from "./datetime";
+export type { SeriesListFunctions as ListSeries } from "./list";
+export type { SeriesStringFunctions as StringSeries } from "./string";
+export type { SeriesStructFunctions as StructSeries } from "./struct";
+declare const inspect: unique symbol;
+/**
+ * A Series represents a single column in a polars DataFrame.
+ */
+export interface Series<T extends DataType = any, Name extends string = string> extends ArrayLike<T>, Rolling<Series<T>>, Arithmetic<Series<T>>, Comparison<Series<T>>, Cumulative<Series<T>>, Round<Series<T>>, Sample<Series<T>>, EwmOps<Series<T>>, Serialize {
+    inner(): any;
+    name: Name;
+    dtype: T;
+    str: SeriesStringFunctions;
+    lst: SeriesListFunctions;
+    struct: SeriesStructFunctions;
+    date: SeriesDateFunctions;
+    [inspect](): string;
+    [Symbol.iterator](): IterableIterator<DTypeToJs<T>>;
+    bitand(other: Series<T>): Series<T, Name>;
+    bitor(other: Series<T>): Series<T, Name>;
+    bitxor(other: Series<T>): Series<T, Name>;
+    /**
+     * Take absolute values
+     */
+    abs(): Series<T, Name>;
+    add(other: number | Series): Series;
+    /**
+     * __Rename this Series.__
+     *
+     * @param name - new name
+     * @see {@link rename}
+     */
+    alias<U extends string>(name: U): Series<T, U>;
+    /**
+     * __Append a Series to this one.__
+     * ___
+     * @param {Series} other - Series to append.
+     * @example
+     * >  const s = pl.Series("a", [1, 2, 3])
+     * >  const s2 = pl.Series("b", [4, 5, 6])
+     * >  s.append(s2)
+     * shape: (6,)
+     * Series: 'a' [i64]
+     * [
+     *         1
+     *         2
+     *         3
+     *         4
+     *         5
+     *         6
+     * ]
+     */
+    append(other: Series): void;
+    /**
+     * Get the index of the maximal value.
+     */
+    argMax(): Optional<number>;
+    /**
+     * Get the index of the minimal value.
+     * @return int
+     * @example
+     * ```
+     * const s = pl.Series("a", [3, 2, 1]);
+     * s.arg_min()
+     * ```
+     */
+    argMin(): Optional<number>;
+    /**
+     * Get index values where Boolean Series evaluate True.
+     */
+    argTrue(): Series<T, Name>;
+    /**
+     * Get unique index as Series.
+     */
+    argUnique(): Series<T, Name>;
+    /**
+     * Get the index values that would sort this Series.
+     * ___
+     * @param descending - Sort in descending order.
+     * @param nullsLast - Place null values last instead of first.
+     * @return {SeriesType} indexes - Indexes that can be used to sort this array.
+     */
+    argSort(descending?: boolean, nullsLast?: boolean): Series<T, Name>;
+    argSort({ descending, nullsLast, }: {
+        descending?: boolean;
+        nullsLast?: boolean;
+    }): Series<T, Name>;
+    argSort({ reverse, // deprecated
+    nullsLast, }: {
+        reverse?: boolean;
+        nullsLast?: boolean;
+    }): Series<T, Name>;
+    argSort(): Series<T, Name>;
+    /**
+     * __Rename this Series.__
+     *
+     * @param name - new name
+     * @see {@link rename} {@link alias}
+     */
+    as<U extends string>(name: string): Series<T, U>;
+    /**
+     * Cast between data types.
+     */
+    cast<const U extends DataType>(dtype: U, strict?: boolean): Series<U>;
+    cast(dtype: DataType, strict?: boolean): Series;
+    /**
+     * Get the length of each individual chunk
+     */
+    chunkLengths(): Array<T>;
+    /**
+     * Cheap deep clones.
+     */
+    clone(): Series<T, Name>;
+    concat(other: Series<T>): Series<T, Name>;
+    /**
+     * __Quick summary statistics of a series. __
+     *
+     * Series with mixed datatypes will return summary statistics for the datatype of the first value.
+     * ___
+     * @example
+     * ```
+     * >  const seriesNum = pl.Series([1,2,3,4,5])
+     * >  series_num.describe()
+     *
+     * shape: (6, 2)
+     * ┌──────────────┬────────────────────┐
+     * │ statistic    ┆ value              │
+     * │ ---          ┆ ---                │
+     * │ str          ┆ f64                │
+     * ╞══════════════╪════════════════════╡
+     * │ "min"        ┆ 1                  │
+     * ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+     * │ "max"        ┆ 5                  │
+     * ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+     * │ "null_count" ┆ 0.0                │
+     * ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+     * │ "mean"       ┆ 3                  │
+     * ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+     * │ "std"        ┆ 1.5811388300841898 │
+     * ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+     * │ "count"      ┆ 5                  │
+     * └──────────────┴────────────────────┘
+     *
+     * >  series_str = pl.Series(["a", "a", None, "b", "c"])
+     * >  series_str.describe()
+     *
+     * shape: (3, 2)
+     * ┌──────────────┬───────┐
+     * │ statistic    ┆ value │
+     * │ ---          ┆ ---   │
+     * │ str          ┆ i64   │
+     * ╞══════════════╪═══════╡
+     * │ "unique"     ┆ 4     │
+     * ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
+     * │ "null_count" ┆ 1     │
+     * ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
+     * │ "count"      ┆ 5     │
+     * └──────────────┴───────┘
+     * ```
+     */
+    describe(): DataFrame;
+    /**
+     * Calculates the n-th discrete difference.
+     * @param n - number of slots to shift
+     * @param nullBehavior - `'ignore' | 'drop'`
+     */
+    diff(n: number, nullBehavior: "ignore" | "drop"): Series<T, Name>;
+    diff({ n, nullBehavior, }: {
+        n: number;
+        nullBehavior: "ignore" | "drop";
+    }): Series<T, Name>;
+    /**
+     * Compute the dot/inner product between two Series
+     * ___
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1, 2, 3])
+     * >  const s2 = pl.Series("b", [4.0, 5.0, 6.0])
+     * >  s.dot(s2)
+     * 32.0
+     * ```
+     */
+    dot(other: Series): number | undefined | null;
+    /**
+     * Create a new Series that copies data from this Series without null values.
+     */
+    dropNulls(): Series<T, Name>;
+    /**
+     * __Explode a list or utf8 Series.__
+     *
+     * This means that every item is expanded to a new row.
+     * ___
+     * @example
+     * ```
+     * >  const s = pl.Series('a', [[1, 2], [3, 4], [9, 10]])
+     * >  s.explode()
+     * shape: (6,)
+     * Series: 'a' [i64]
+     * [
+     *         1
+     *         2
+     *         3
+     *         4
+     *         9
+     *         10
+     * ]
+     * ```
+     */
+    explode(): any;
+    /**
+     * Extend the Series with given number of values.
+     * @param value The value to extend the Series with. This value may be null to fill with nulls.
+     * @param n The number of values to extend.
+     */
+    extendConstant(value: any, n: number): Series;
+    extendConstant(opt: {
+        value: any;
+        n: number;
+    }): Series;
+    /**
+     * __Fill null values with a filling strategy.__
+     * ___
+     * @param strategy - Filling Strategy
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1, 2, 3, None])
+     * >  s.fill_null('forward'))
+     * shape: (4,)
+     * Series: '' [i64]
+     * [
+     *         1
+     *         2
+     *         3
+     *         3
+     * ]
+     * >  s.fill_null('min'))
+     * shape: (4,)
+     * Series: 'a' [i64]
+     * [
+     *         1
+     *         2
+     *         3
+     *         1
+     * ]
+     * ```
+     */
+    fillNull(strategy: "backward" | "forward" | "min" | "max" | "mean" | "one" | "zero"): Series;
+    fillNull({ strategy, }: {
+        strategy: "backward" | "forward" | "min" | "max" | "mean" | "one" | "zero";
+    }): Series;
+    /**
+     * __Filter elements by a boolean mask.__
+     * @param {SeriesType} predicate - Boolean mask
+     */
+    filter(predicate: Series): Series;
+    filter({ predicate }: {
+        predicate: Series;
+    }): Series;
+    get(index: number): any;
+    getIndex(n: number): any;
+    /**
+     * Returns True if the Series has a validity bitmask.
+     * If there is none, it means that there are no null values.
+     */
+    hasValidity(): boolean;
+    /**
+     * Hash the Series
+     * The hash value is of type `UInt64`
+     * ___
+     * @param k0 - seed parameter
+     * @param k1 - seed parameter
+     * @param k2 - seed parameter
+     * @param k3 - seed parameter
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1, 2, 3])
+     * >  s.hash(42)
+     * shape: (3,)
+     * Series: 'a' [u64]
+     * [
+     *   7499844439152382372
+     *   821952831504499201
+     *   6685218033491627602
+     * ]
+     * ```
+     */
+    hash(k0?: number | bigint, k1?: number | bigint, k2?: number | bigint, k3?: number | bigint): Series;
+    hash({ k0, k1, k2, k3, }: {
+        k0?: number | bigint;
+        k1?: number | bigint;
+        k2?: number | bigint;
+        k3?: number | bigint;
+    }): Series;
+    /**
+     * __Get first N elements as Series.__
+     * ___
+     * @param length  Length of the head
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1, 2, 3])
+     * >  s.head(2)
+     * shape: (2,)
+     * Series: 'a' [i64]
+     * [
+     *         1
+     *         2
+     * ]
+     * ```
+     */
+    head(length?: number): Series;
+    /**
+     * __Interpolate intermediate values.__
+     *
+     * The interpolation method is linear.
+     * ___
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1, 2, None, None, 5])
+     * >  s.interpolate()
+     * shape: (5,)
+     * Series: 'a' [i64]
+     * [
+     *         1
+     *         2
+     *         3
+     *         4
+     *         5
+     * ]
+     * ```
+     */
+    interpolate(method?: InterpolationMethod): Series;
+    /**
+     * Check if this Series is a Boolean.
+     */
+    isBoolean(): this is Series<Bool>;
+    /**
+     * Check if this Series is a DataTime.
+     */
+    isDateTime(): boolean;
+    /**
+     * __Get mask of all duplicated values.__
+     *
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1, 2, 2, 3])
+     * >  s.isDuplicated()
+     *
+     * shape: (4,)
+     * Series: 'a' [bool]
+     * [
+     *         false
+     *         true
+     *         true
+     *         false
+     * ]
+     * ```
+     */
+    isDuplicated(): Series;
+    /**
+     * Get mask of finite values if Series dtype is Float.
+     */
+    isFinite(): Series;
+    /**
+     * Get a mask of the first unique value.
+     */
+    isFirstDistinct(): Series;
+    /**
+     * Check if this Series is a Float.
+     */
+    isFloat(): boolean;
+    /**
+     * Check if elements of this Series are in the right Series, or List values of the right Series.
+     */
+    isIn<U>(other: Series | U[]): Series;
+    /**
+     * __Get mask of infinite values if Series dtype is Float.__
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1.0, 2.0, 3.0])
+     * >  s.isInfinite()
+     *
+     * shape: (3,)
+     * Series: 'a' [bool]
+     * [
+     *         false
+     *         false
+     *         false
+     * ]
+     * ```
+     */
+    isInfinite(): Series;
+    /**
+     * __Get mask of non null values.__
+     *
+     * *`undefined` values are treated as null*
+     * ___
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1.0, undefined, 2.0, 3.0, null])
+     * >  s.isNotNull()
+     * shape: (5,)
+     * Series: 'a' [bool]
+     * [
+     *         true
+     *         false
+     *         true
+     *         true
+     *         false
+     * ]
+     * ```
+     */
+    isNotNull(): Series;
+    /**
+     * __Get mask of null values.__
+     *
+     * `undefined` values are treated as null
+     * ___
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1.0, undefined, 2.0, 3.0, null])
+     * >  s.isNull()
+     * shape: (5,)
+     * Series: 'a' [bool]
+     * [
+     *         false
+     *         true
+     *         false
+     *         false
+     *         true
+     * ]
+     * ```
+     */
+    isNull(): Series;
+    /**
+     * Check if this Series datatype is numeric.
+     */
+    isNumeric(): this is Series<DataType.Int8 | DataType.Int16 | DataType.Int32 | DataType.Int64 | DataType.UInt8 | DataType.UInt16 | DataType.UInt32 | DataType.UInt64 | DataType.Float32 | DataType.Float64 | DataType.Decimal>;
+    /**
+     * __Get mask of unique values.__
+     * ___
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1, 2, 2, 3])
+     * >  s.isUnique()
+     * shape: (4,)
+     * Series: 'a' [bool]
+     * [
+     *         true
+     *         false
+     *         false
+     *         true
+     * ]
+     * ```
+     */
+    isUnique(): Series;
+    /**
+     * Checks if this Series datatype is a String.
+     */
+    isString(): boolean;
+    /**
+     * __Compute the kurtosis (Fisher or Pearson) of a dataset.__
+     *
+     * Kurtosis is the fourth central moment divided by the square of the
+     * variance. If Fisher's definition is used, then 3.0 is subtracted from
+     * the result to give 0.0 for a normal distribution.
+     * If bias is False then the kurtosis is calculated using k statistics to
+     * eliminate bias coming from biased moment estimators
+     * ___
+     * @param fisher -
+     * - If True, Fisher's definition is used (normal ==> 0.0).
+     * - If False, Pearson's definition is used (normal ==> 3.0)
+     * @param bias : bool, optional If False, the calculations are corrected for statistical bias.
+     */
+    kurtosis(fisher: boolean, bias?: boolean): Optional<number>;
+    kurtosis({ fisher, bias, }: {
+        fisher?: boolean;
+        bias?: boolean;
+    }): Optional<number>;
+    kurtosis(): Optional<number>;
+    /**
+     * __Length of this Series.__
+     * ___
+     * @example
+     * ```
+     * >  const s = pl.Series("a", [1, 2, 3])
+     * >  s.len()
+     * 3
+     * ```
+     */
+    len(): number;
+    /**
+     * __Take `n` elements from this Series.__
+     * ___
+     * @param n - Amount of elements to take.
+     * @see {@link head}
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 3])
+     * s.limit(2)
+     * shape: (2,)
+     * Series: 'a' [i64]
+     * [
+     *         1
+     *         2
+     * ]
+     * ```
+     */
+    limit(n?: number): Series;
+    /**
+     * Get the maximum value in this Series.
+     * @example
+     * ```
+     * > s = pl.Series("a", [1, 2, 3])
+     * > s.max()
+     * 3
+     * ```
+     */
+    max(): number;
+    /**
+     * Reduce this Series to the mean value.
+     * @example
+     * ```
+     * > s = pl.Series("a", [1, 2, 3])
+     * > s.mean()
+     * 2
+     * ```
+     */
+    mean(): number;
+    /**
+     * Get the median of this Series
+     * @example
+     * ```
+     * > s = pl.Series("a", [1, 2, 3])
+     * > s.median()
+     * 2
+     * ```
+     */
+    median(): number;
+    /**
+     * Get the minimal value in this Series.
+     * @example
+     * ```
+     * > s = pl.Series("a", [1, 2, 3])
+     * > s.min()
+     * 1
+     * ```
+     */
+    min(): number;
+    /**
+     * __Compute the most occurring value(s). Can return multiple Values__
+     * ___
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 2, 3])
+     * s.mode()
+     * shape: (1,)
+     * Series: 'a' [i64]
+     * [
+     *         2
+     * ]
+     *
+     * s = pl.Series("a", ['a', 'b', 'c', 'c', 'b'])
+     * s.mode()
+     * shape: (1,)
+     * Series: 'a' [str]
+     * [
+     *         'b'
+     *         'c'
+     * ]
+     * ```
+     */
+    mode(): Series;
+    /**
+     * Get the number of chunks that this Series contains.
+     */
+    nChunks(): number;
+    /**
+     * __Count the number of unique values in this Series.__
+     * ___
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 2, 3])
+     * s.nUnique()
+     * 3
+     * ```
+     */
+    nUnique(): number;
+    /**
+     * Count the null values in this Series. --
+     * _`undefined` values are treated as null_
+     */
+    nullCount(): number;
+    /**
+     * Get a boolean mask of the local maximum peaks.
+     * ___
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 3, 4, 5])
+     * s.peakMax()
+     * shape: (5,)
+     * Series: '' [bool]
+     * [
+     *         false
+     *         false
+     *         false
+     *         false
+     *         true
+     * ]
+     * ```
+     */
+    peakMax(): Series;
+    /**
+     * Get a boolean mask of the local minimum peaks.
+     * ___
+     * @example
+     * ```
+     * s = pl.Series("a", [4, 1, 3, 2, 5])
+     * s.peakMin()
+     * shape: (5,)
+     * Series: '' [bool]
+     * [
+     *         false
+     *         true
+     *         false
+     *         true
+     *         false
+     * ]
+     * ```
+     */
+    peakMin(): Series;
+    /**
+     * Get the quantile value of this Series.
+     * ___
+     * @param quantile
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 3])
+     * s.quantile(0.5)
+     * 2
+     * ```
+     */
+    quantile(quantile: number, interpolation?: string): number;
+    /**
+     * Assign ranks to data, dealing with ties appropriately.
+     * The method used to assign ranks to tied elements.
+     * @param method {'average', 'min', 'max', 'dense', 'ordinal', 'random'}
+     * The following methods are available: _default is 'average'_
+     *
+     *  *   __'average'__: The average of the ranks that would have been assigned to
+     *    all the tied values is assigned to each value.
+     *  * __'min'__: The minimum of the ranks that would have been assigned to all
+     *    the tied values is assigned to each value.  _This is also
+     *    referred to as "competition" ranking._
+     *  * __'max'__: The maximum of the ranks that would have been assigned to all
+     *    the tied values is assigned to each value.
+     *  * __'dense'__: Like 'min', but the rank of the next highest element is
+     *    assigned the rank immediately after those assigned to the tied
+     *    elements.
+     *  * __'ordinal'__: All values are given a distinct rank, corresponding to
+     *    the order that the values occur in `a`.
+     *  * __'random'__: Like 'ordinal', but the rank for ties is not dependent
+     *    on the order that the values occur in `a`.
+     * @param descending - Rank in descending order.
+     */
+    rank(method?: RankMethod, descending?: boolean): Series;
+    rechunk(): Series;
+    rechunk(inPlace: true): Series;
+    rechunk(inPlace: false): void;
+    /**
+     * __Reinterpret the underlying bits as a signed/unsigned integer.__
+     *
+     * This operation is only allowed for 64bit integers. For lower bits integers,
+     * you can safely use that cast operation.
+     * ___
+     * @param signed signed or unsigned
+     *
+     * - True -> pl.Int64
+     * - False -> pl.UInt64
+     * @see {@link cast}
+     */
+    reinterpret(signed?: boolean): Series;
+    /**
+     * __Rename this Series.__
+     *
+     * @param name - new name
+     * @param inPlace - Modify the Series in-place.
+     * @see {@link alias}
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 3])
+     * s.rename('b')
+     * shape: (3,)
+     * Series: 'b' [i64]
+     * [
+     *         1
+     *         2
+     *         3
+     * ]
+     * ```
+     */
+    rename(name: string, inPlace: boolean): void;
+    rename(name: string): Series;
+    rename({ name, inPlace }: {
+        name: string;
+        inPlace?: boolean;
+    }): void;
+    rename({ name, inPlace }: {
+        name: string;
+        inPlace: true;
+    }): void;
+    /**
+     * __Check if series is equal with another Series.__
+     * @param other - Series to compare with.
+     * @param nullEqual - Consider null values as equal. _('undefined' is treated as null)_
+     * ___
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 3])
+     * s2 = pl.Series("b", [4, 5, 6])
+     * s.series_equal(s)
+     * true
+     * s.series_equal(s2)
+     * false
+     * ```
+     */
+    seriesEqual<_U1>(other: Series, nullEqual?: boolean, strict?: boolean): boolean;
+    /**
+     * __Set masked values__
+     * @param filter Boolean mask
+     * @param value value to replace masked values with
+     */
+    set(filter: Series, value: any): Series;
+    scatter(indices: number[] | Series, value: any): void;
+    /**
+     * __Shift the values by a given period__
+     *
+     * the parts that will be empty due to this operation will be filled with `null`.
+     * ___
+     * @param periods - Number of places to shift (may be negative).
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 3])
+     * s.shift(1)
+     * shape: (3,)
+     * Series: 'a' [i64]
+     * [
+     *         null
+     *         1
+     *         2
+     * ]
+     * s.shift(-1)
+     * shape: (3,)
+     * Series: 'a' [i64]
+     * [
+     *         2
+     *         3
+     *         null
+     * ]
+     * ```
+     */
+    shift(periods: number): Series;
+    /**
+     * Shift the values by a given period
+     *
+     * the parts that will be empty due to this operation will be filled with `fillValue`.
+     * ___
+     * @param periods - Number of places to shift (may be negative).
+     * @param fillValue - Fill null & undefined values with the result of this expression.
+     */
+    shiftAndFill(periods: number, fillValue: number): Series;
+    shiftAndFill(args: {
+        periods: number;
+        fillValue: number;
+    }): Series;
+    /**
+     * __Shrink memory usage of this Series to fit the exact capacity needed to hold the data.__
+     * @param inPlace - Modify the Series in-place.
+     */
+    shrinkToFit(inPlace: true): void;
+    shrinkToFit(): Series;
+    /**
+     * __Compute the sample skewness of a data set.__
+     *
+     * For normally distributed data, the skewness should be about zero. For
+     * unimodal continuous distributions, a skewness value greater than zero means
+     * that there is more weight in the right tail of the distribution. The
+     * function `skewtest` can be used to determine if the skewness value
+     * is close enough to zero, statistically speaking.
+     * ___
+     * @param bias - If false, then the calculations are corrected for statistical bias.
+     */
+    skew(bias?: boolean): number | undefined;
+    /**
+     * Create subslices of the Series.
+     *
+     * @param start - Start of the slice (negative indexing may be used).
+     * @param length - length of the slice.
+     */
+    slice(start: number, length?: number): Series;
+    /**
+     * __Sort this Series.__
+     * @param options.descending - Sort in descending order.
+     * @param options.nullsLast - Place nulls at the end.
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 3, 4, 2])
+     * s.sort()
+     * shape: (4,)
+     * Series: 'a' [i64]
+     * [
+     *         1
+     *         2
+     *         3
+     *         4
+     * ]
+     * s.sort({descending: true})
+     * shape: (4,)
+     * Series: 'a' [i64]
+     * [
+     *         4
+     *         3
+     *         2
+     *         1
+     * ]
+     * ```
+     */
+    sort(options: {
+        descending?: boolean;
+        nullsLast?: boolean;
+    }): Series;
+    sort(options: {
+        reverse?: boolean;
+        nullsLast?: boolean;
+    }): Series;
+    sort(): Series;
+    /**
+     * Reduce this Series to the sum value.
+     * @example
+     * ```
+     * > s = pl.Series("a", [1, 2, 3])
+     * > s.sum()
+     * 6
+     * ```
+     */
+    sum(): number;
+    /**
+     * __Get last N elements as Series.__
+     *
+     * ___
+     * @param length - Length of the tail
+     * @see {@link head}
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 3])
+     * s.tail(2)
+     * shape: (2,)
+     * Series: 'a' [i64]
+     * [
+     *         2
+     *         3
+     * ]
+     * ```
+     */
+    tail(length?: number): Series;
+    /**
+     * Take every nth value in the Series and return as new Series.
+     * @param n - Gather every *n*-th row
+     * @param offset - Start the row count at this offset
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 3, 4])
+     * s.gatherEvery(2))
+     * shape: (2,)
+     * Series: 'a' [i64]
+     * [
+     *     1
+     *     3
+     * ]
+     * s.gather_every(2, offset=1)
+     * shape: (2,)
+     * Series: 'a' [i64]
+     * [
+     *     2
+     *     4
+     * ]
+     * ```
+     */
+    gatherEvery(n: number, offset?: number): Series;
+    /**
+     * Take values by index.
+     * ___
+     * @param indices - Index location used for the selection
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 3, 4])
+     * s.gather([1, 3])
+     * shape: (2,)
+     * Series: 'a' [i64]
+     * [
+     *         2
+     *         4
+     * ]
+     * ```
+     */
+    gather(indices: Array<number>): Series;
+    /**
+     * __Get unique elements in series.__
+     * ___
+     * @param maintainOrder Maintain order of data. This requires more work.
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 2, 3])
+     * s.unique()
+     * shape: (3,)
+     * Series: 'a' [i64]
+     * [
+     *         1
+     *         2
+     *         3
+     * ]
+     * ```
+     */
+    unique(maintainOrder?: boolean | {
+        maintainOrder: boolean;
+    }): Series;
+    /**
+     * __Count the unique values in a Series.__
+     * @param sort - Sort the output by count in descending order.
+     *               If set to `False` (default), the order of the output is random.
+     * @param parallel - Execute the computation in parallel.
+              .. note::
+                  This option should likely not be enabled in a group by context,
+                  as the computation is already parallelized per group.
+     * @param name - Give the resulting count column a specific name;
+              if `normalize` is True defaults to "count", otherwise defaults to "proportion".
+     * @param normalize - If true gives relative frequencies of the unique values
+     * ___
+     * @example
+     * ```
+     * s = pl.Series("a", [1, 2, 2, 3])
+     * s.valueCounts()
+     * shape: (3, 2)
+     * ╭─────┬────────╮
+     * │ a   ┆ counts │
+     * │ --- ┆ ---    │
+     * │ i64 ┆ u32    │
+     * ╞═════╪════════╡
+     * │ 2   ┆ 2      │
+     * ├╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
+     * │ 1   ┆ 1      │
+     * ├╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
+     * │ 3   ┆ 1      │
+     * ╰─────┴────────╯
+     * ```
+     */
+    valueCounts(sort?: boolean, parallel?: boolean, name?: string, normalize?: boolean): DataFrame;
+    /**
+     * Where mask evaluates true, take values from self.
+     *
+     * Where mask evaluates false, take values from other.
+     * ___
+     * @param mask - Boolean Series
+     * @param other - Series of same type
+     */
+    zipWith(mask: Series, other: Series): Series;
+    /**
+     * __Convert this Series to a Javascript Array.__
+     *
+     * This operation clones data, and is very slow, but maintains greater precision for all dtypes.
+     * Often times `series.toObject().values` is faster, but less precise
+     * ___
+     * @example
+     * ```
+     * const s = pl.Series("a", [1, 2, 3])
+     * const arr = s.toArray()
+     * [1, 2, 3]
+     * Array.isArray(arr)
+     * true
+     * ```
+     */
+    toArray(): Array<DTypeToJs<T>>;
+    /**
+     * Converts series to a javascript typedArray.
+     *
+     * __Warning:__
+     * This will throw an error if you have nulls, or are using non numeric data types
+     */
+    toTypedArray(): any;
+    /**
+     * Get dummy/indicator variables.
+     * @param separator str = "_",
+     * @param dropFirst bool = False
+     * @param dropNulls bool = False,
+     *
+     * @example
+     * const s = pl.Series("a", [1, 2, 3])
+      >>> s.toDummies()
+      shape: (3, 3)
+      ┌─────┬─────┬─────┐
+      │ a_1 ┆ a_2 ┆ a_3 │
+      │ --- ┆ --- ┆ --- │
+      │ u8  ┆ u8  ┆ u8  │
+      ╞═════╪═════╪═════╡
+      │ 1   ┆ 0   ┆ 0   │
+      │ 0   ┆ 1   ┆ 0   │
+      │ 0   ┆ 0   ┆ 1   │
+      └─────┴─────┴─────┘
+  
+      >>> s.toDummies(":", true)
+      shape: (3, 2)
+      ┌─────┬─────┐
+      │ a:2 ┆ a:3 │
+      │ --- ┆ --- │
+      │ u8  ┆ u8  │
+      ╞═════╪═════╡
+      │ 0   ┆ 0   │
+      │ 1   ┆ 0   │
+      │ 0   ┆ 1   │
+      └─────┴─────┘
+     *
+     */
+    toDummies(separator?: string, dropFirst?: boolean, dropNulls?: boolean): DataFrame;
+    /**
+     * _Returns a Javascript object representation of Series_
+     * Often this is much faster than the iterator, or `values` method
+     *
+     * @example
+     * ```
+     * const s = pl.Series("foo", [1,2,3])
+     * s.toObject()
+     * {
+     *   name: "foo",
+     *   datatype: "Float64",
+     *   values: [1,2,3]
+     * }
+     * ```
+     */
+    toObject(): {
+        name: Name;
+        datatype: DtypeToJsName<T>;
+        values: DTypeToJs<T>[];
+    };
+    toFrame(): DataFrame;
+    /** compat with `JSON.stringify */
+    toJSON(): string;
+    /** Returns an iterator over the values */
+    values(): IterableIterator<any>;
+}
+/** @ignore */
+export declare function _Series(_s: any): Series;
+/**
+ * @ignore
+ * @inheritDoc {Series}
+ */
+export interface SeriesConstructor extends Deserialize<Series> {
+    /**
+     * Creates a new Series from a set of values.
+     * @param values — A set of values to include in the new Series object.
+     * @example
+     * ```
+     * >  pl.Series([1, 2, 3])
+     * shape: (3,)
+     * Series: '' [f64]
+     * [
+     *         1
+     *         2
+     *         3
+     * ]
+     * ```
+     */
+    <T extends JsType>(values: ArrayLike<T | null>): Series<JsToDtype<T>>;
+    (values: any): Series;
+    /**
+     * Create a new named series
+     * @param name - The name of the series
+     * @param values - A set of values to include in the new Series object.
+     * @example
+     * ```
+     * >  pl.Series('foo', [1, 2, 3])
+     * shape: (3,)
+     * Series: 'foo' [f64]
+     * [
+     *         1
+     *         2
+     *         3
+     * ]
+     * ```
+     */
+    <T1 extends JsType, Name extends string>(name: Name, values: ArrayLike<T1 | null>): Series<JsToDtype<T1>, Name>;
+    <T2 extends DataType, Name extends string>(name: Name, values: ArrayLike<DTypeToJsLoose<T2 | null>>, dtype?: T2): Series<T2, Name>;
+    (name: string, values: any[], dtype?: any): Series;
+    /**
+     * Creates an array from an array-like object.
+     * @param arrayLike — An array-like object to convert to an array.
+     */
+    from<T1 extends JsType>(arrayLike: ArrayLike<T1>): Series<JsToDtype<T1>>;
+    from<T1>(arrayLike: ArrayLike<T1>): Series;
+    from<T2 extends JsType, Name extends string>(name: Name, arrayLike: ArrayLike<T2>): Series<JsToDtype<T2>, Name>;
+    from<T2>(name: string, arrayLike: ArrayLike<T2>): Series;
+    /**
+     * Returns a new Series from a set of elements.
+     * @param items — A set of elements to include in the new Series object.
+     */
+    of<T3 extends JsType>(items: T3[]): Series<JsToDtype<T3>>;
+    of<T3>(items: T3[]): Series;
+    isSeries(arg: any): arg is Series;
+}
+export declare const Series: SeriesConstructor;