export declare function getDualSemigroup<A>(S: Semigroup<A>): Semigroup<A>

import { getDualSemigroup, semigroupString } from 'fp-ts/lib/Semigroup'

assert.deepStrictEqual(getDualSemigroup(semigroupString).concat('a', 'b'), 'ba')

export declare function getFirstSemigroup<A = never>(): Semigroup<A>

export declare function getFunctionSemigroup<S>(S: Semigroup<S>): <A = never>() => Semigroup<(a: A) => S>

export declare function getIntercalateSemigroup<A>(a: A): (S: Semigroup<A>) => Semigroup<A>

import { getIntercalateSemigroup, semigroupString } from 'fp-ts/lib/Semigroup'

const S = getIntercalateSemigroup(' ')(semigroupString)

assert.strictEqual(S.concat('a', 'b'), 'a b')
assert.strictEqual(S.concat(S.concat('a', 'b'), 'c'), S.concat('a', S.concat('b', 'c')))

export declare function getJoinSemigroup<A>(O: Ord<A>): Semigroup<A>

export declare function getLastSemigroup<A = never>(): Semigroup<A>

export declare function getMeetSemigroup<A>(O: Ord<A>): Semigroup<A>

export declare function getObjectSemigroup<A extends object = never>(): Semigroup<A>

import { getObjectSemigroup } from 'fp-ts/lib/Semigroup'

interface Person {
  name: string
  age: number
}

const S = getObjectSemigroup<Person>()
assert.deepStrictEqual(S.concat({ name: 'name', age: 23 }, { name: 'name', age: 24 }), { name: 'name', age: 24 })

export declare function getStructSemigroup<O extends ReadonlyRecord<string, any>>(
  semigroups: { [K in keyof O]: Semigroup<O[K]> }
): Semigroup<O>

export declare function getTupleSemigroup<T extends ReadonlyArray<Semigroup<any>>>(
  ...semigroups: T
): Semigroup<{ [K in keyof T]: T[K] extends Semigroup<infer A> ? A : never }>

import { getTupleSemigroup, semigroupString, semigroupSum, semigroupAll } from 'fp-ts/lib/Semigroup'

const S1 = getTupleSemigroup(semigroupString, semigroupSum)
assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])

const S2 = getTupleSemigroup(semigroupString, semigroupSum, semigroupAll)
assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])

export declare const semigroupAll: Semigroup<boolean>

export declare const semigroupAny: Semigroup<boolean>

export declare const semigroupProduct: Semigroup<number>

export declare const semigroupString: Semigroup<string>

export declare const semigroupSum: Semigroup<number>

export declare const semigroupVoid: Semigroup<void>

export interface Semigroup<A> extends Magma<A> {}

export declare function fold<A>(
  S: Semigroup<A>
): {
  (a: A): (as: ReadonlyArray<A>) => A
  (a: A, as: ReadonlyArray<A>): A
}

import * as S from 'fp-ts/lib/Semigroup'

const sum = S.fold(S.semigroupSum)(0)

assert.deepStrictEqual(sum([1, 2, 3]), 6)