export declare const apFirst: <E, B>(second: Vec<E, B>) => <A>(first: Vec<E, A>) => Vec<E, A>

export declare const apSecond: <E, B>(second: Vec<E, B>) => <A>(first: Vec<E, A>) => Vec<E, B>

export declare const chainFirst: <A, B>(f: (a: A) => Vec<1, B>) => (first: Vec<1, A>) => Vec<1, A>

export declare const fromReadonlyArray: <N extends number>(n: N) => <A>(as: readonly A[]) => O.Option<Vec<N, A>>

export declare const fromTuple: {
  <A>(t: []): Vec<0, A>
  <A>(t: [A]): Vec<1, A>
  <A>(t: [A, A]): Vec<2, A>
  <A>(t: [A, A, A]): Vec<3, A>
  <A>(t: [A, A, A, A]): Vec<4, A>
  <A>(t: [A, A, A, A, A]): Vec<5, A>
  <A>(t: [A, A, A, A, A, A]): Vec<6, A>
  <A>(t: [A, A, A, A, A, A, A]): Vec<7, A>
  <A>(t: [A, A, A, A, A, A, A, A]): Vec<8, A>
  <A>(t: [A, A, A, A, A, A, A, A, A]): Vec<9, A>
  <A>(t: [A, A, A, A, A, A, A, A, A, A]): Vec<10, A>
}

export declare const makeBy: <N extends number, A>(n: N, make: (i: number) => A) => Vec<N, A>

export declare const randVec: <N extends number, A>(n: N, make: IO.IO<A>) => IO.IO<Vec<N, A>>

export declare const repeat: <N extends number, A>(n: N, a: A) => Vec<N, A>

export declare const l1Norm: <A extends number | Complex>(R: Rng.Ring<A>) => <N>(x: Vec<N, A>) => A

export declare const l2Norm: <A extends number | Complex>(
  R: Rng.Ring<A>,
  abs: (x: A) => A,
  pow: (x: A, n: number) => A
) => <N>(x: Vec<N, A>) => A

export declare const lInfNorm: <A>(B: Bnd.Bounded<A>, abs: (a: A) => A) => <N>(x: Vec<N, A>) => A

export declare const lpNorm: (
  p: number
) => <A extends number | Complex>(
  R: Rng.Ring<A>,
  abs: (x: A) => A,
  pow: (x: A, n: number) => A
) => <N>(x: Vec<N, A>) => A

export declare const size: <N extends number, A>(v: Vec<N, A>) => N

export declare const toTuple: {
  <A>(t: Vec<0, A>): []
  <A>(t: Vec<1, A>): [A]
  <A>(t: Vec<2, A>): [A, A]
  <A>(t: Vec<3, A>): [A, A, A]
  <A>(t: Vec<4, A>): [A, A, A, A]
  <A>(t: Vec<5, A>): [A, A, A, A, A]
  <A>(t: Vec<6, A>): [A, A, A, A, A, A]
  <A>(t: Vec<7, A>): [A, A, A, A, A, A, A]
  <A>(t: Vec<8, A>): [A, A, A, A, A, A, A, A]
  <A>(t: Vec<9, A>): [A, A, A, A, A, A, A, A, A]
  <A>(t: Vec<10, A>): [A, A, A, A, A, A, A, A, A, A]
}

export declare const apS: <N, A, E, B>(
  name: Exclude<N, keyof A>,
  fb: Vec<E, B>
) => (fa: Vec<E, A>) => Vec<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>

export declare const bind: <N, A, B>(
  name: Exclude<N, keyof A>,
  f: (a: A) => Vec<1, B>
) => (ma: Vec<1, A>) => Vec<1, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>

export declare const bindTo: <N>(name: N) => <E, A>(fa: Vec<E, A>) => Vec<E, { readonly [K in N]: A }>

export declare const ap: <N, A, B>(fa: Vec<N, A>) => (fab: Vec<N, (a: A) => B>) => Vec<N, B>

export declare const chain: <A, B>(f: (a: A) => Vec<1, B>) => <N>(ma: Vec<N, A>) => Vec<N, B>

export declare const foldMap: <M>(M: Mn.Monoid<M>) => <N, A>(f: (a: A) => M) => (fa: Vec<N, A>) => M

export declare const foldMapWithIndex: <M>(M: Mn.Monoid<M>) => <N, A>(f: (i: number, a: A) => M) => (fa: Vec<N, A>) => M

export declare const map: <N, A, B>(f: (a: A) => B) => (v: Vec<N, A>) => Vec<N, B>

export declare const mapWithIndex: <N, A, B>(f: (i: number, a: A) => B) => (v: Vec<N, A>) => Vec<N, B>

export declare const of: <A>(a: A) => Vec<1, A>

export declare const reduce: <N, A, B>(b: B, f: (b: B, a: A) => B) => (fa: Vec<N, A>) => B

export declare const reduceRight: <N, B, A>(b: A, f: (b: B, a: A) => A) => (fa: Vec<N, B>) => A

export declare const reduceRightWithIndex: <N, B, A>(b: A, f: (i: number, b: B, a: A) => A) => (fa: Vec<N, B>) => A

export declare const reduceWithIndex: <N, A, B>(b: B, f: (i: number, b: B, a: A) => B) => (fa: Vec<N, A>) => B

export declare const sequence: <F>(F: Apl.Applicative<F>) => <N, A>(fa: Vec<N, HKT<F, A>>) => HKT<F, Vec<N, A>>

export declare const traverse: Tr.PipeableTraverse2<'Vec'>

export declare const traverseWithIndex: TrI.PipeableTraverseWithIndex2<'Vec', number>

export declare const Applicative: Apl.Applicative2C<'Vec', 1>

export declare const Apply: Ap.Apply2<'Vec'>

export declare const Chain: Chn.Chain2C<'Vec', 1>

export declare const Foldable: Fl.Foldable2<'Vec'>

export declare const FoldableWithIndex: FlI.FoldableWithIndex2<'Vec', number>

export declare const Functor: Fun.Functor2<'Vec'>

export declare const FunctorWithIndex: FunI.FunctorWithIndex2<'Vec', number>

export declare const Monad: Mon.Monad2C<'Vec', 1>

export declare const Pointed: Pt.Pointed2C<'Vec', 1>

export declare const Traversable: Tr.Traversable2<'Vec'>

export declare const TraversableWithIndex: TrI.TraversableWithIndex2<'Vec', number>

export declare const URI: 'Vec'

export type URI = typeof URI

export declare const getAdditiveAbelianGroup: <A>(
  R: Rng.Ring<A>
) => <N extends number>(n: N) => TC.AbelianGroup<Vec<N, A>>

export declare const getBimodule: <R>(R: Rng.Ring<R>) => <N extends number>(n: N) => TC.Bimodule<Vec<N, R>, R, R>

export interface Vec<N, A> extends ReadonlyArray<A> {
  _length: N
}

export declare const append: <A>(head: A) => <P extends number, N extends number>(v: Vec<N, A>) => Vec<P, A>

export declare const crossProduct: <A>(R: Rng.Ring<A>) => (x: Vec<3, A>, y: Vec<3, A>) => Vec<3, A>

export declare const get: (i: number) => <N, A>(fa: Vec<N, A>) => O.Option<A>

export declare const innerProduct: <A extends number | Complex>(
  R: Rng.Ring<A>,
  conj: (r: A) => A
) => <N>(x: Vec<N, A>, y: Vec<N, A>) => A

export declare const lift2: <A, B>(f: (x: A, y: A) => B) => <N>(x: Vec<N, A>, y: Vec<N, A>) => Vec<N, B>

export declare const mapIndex: (n: number) => <A>(f: (a: A) => A) => <N>(fa: Vec<N, A>) => O.Option<Vec<N, A>>

export declare const prepend: <A>(head: A) => <P extends number, N extends number>(v: Vec<N, A>) => Vec<P, A>

export declare const projection: <R extends number | Complex>(
  F: Fld.Field<R>,
  conj: (r: R) => R
) => <N extends number>(u: Vec<N, R>, v: Vec<N, R>) => Vec<N, R>

export declare const reverse: <N, A>(v1: Vec<N, A>) => Vec<N, A>

export declare const switchIndices: (i: number, j: number) => <N extends number, A>(v: Vec<N, A>) => O.Option<Vec<N, A>>

export declare const updateAt: (n: number) => <A>(a: A) => <N>(fa: Vec<N, A>) => O.Option<Vec<N, A>>

export declare const zipVectors: <N, A, B>(v1: Vec<N, A>, v2: Vec<N, B>) => Vec<N, readonly [A, B]>