export declare const fromIterable: <V>({
  content,
  stringKey,
  depth
}: {
  readonly content: V
  readonly stringKey: MTypes.OverOne<string>
  readonly depth: number
}) => Type<V>

export declare const fromNonPrimitiveValueAndKey: ({
  nonPrimitiveContent,
  key,
  depth,
  protoDepth
}: {
  readonly nonPrimitiveContent: MTypes.NonPrimitive
  readonly key: string | symbol
  readonly depth: number
  readonly protoDepth: number
}) => All

export declare const fromTopValue: <V>(content: V) => Type<V>

export declare const content: <V>(self: Type<V>) => V

export declare const contentType: MTypes.OneArgFunction<All, MTypes.Category.Type>

export declare const depth: MTypes.OneArgFunction<All, number>

export declare const hasSymbolicKey: MTypes.OneArgFunction<All, boolean>

export declare const isEnumerable: MTypes.OneArgFunction<All, boolean>

export declare const oneLineStringKey: MTypes.OneArgFunction<All, string>

export declare const protoDepth: MTypes.OneArgFunction<All, number>

export declare const stringKey: MTypes.OneArgFunction<All, MTypes.OverOne<string>>

export declare const equivalence: Equivalence.Equivalence<All>

export declare const has: (u: unknown) => u is All

export declare const isFunction: (u: All) => u is Type<MTypes.AnyFunction>

export declare const isNonPrimitive: (u: All) => u is NonPrimitive

export declare const isPrimitive: (u: All) => u is Primitive

export interface All extends Type<unknown> {}

export interface NonPrimitive extends Type<MTypes.NonPrimitive> {}

export interface Primitive extends Type<MTypes.Primitive> {}

export interface Type<out V> extends Equal.Equal, Inspectable.Inspectable, Pipeable.Pipeable {
  /** The value */
  readonly content: V

  /** Type of content */
  readonly contentType: MTypes.Category.Type

  /**
   * Depth of this value in the value to stringify: number of nested non-primitive values to open to
   * reach this value.
   */
  readonly depth: number

  /** Depth of this value in the prototypal chain of a non-primitive value */
  readonly protoDepth: number

  /**
   * Array of strings representing the key associated to that value if any. If this value is not in
   * a non-primitive value, i.e. it is itself the value to stringify, `stringKey` is an array
   * containing an empty string. If it is the value of one of the properties of a non-primitive
   * value, `stringKey` is a one-element array containing the property key converted to a string. If
   * it is one of the values of an iterable non-primitive value (e.g. a Map), `stringKey` is the
   * unstyled stringified key associated to the value.
   */
  readonly stringKey: MTypes.OverOne<string>

  /** Same as stringKey, but all lines are joined with an empty string */
  readonly oneLineStringKey: string

  /**
   * `true` if this value is the value of one of the properties of a non-primitive value whose
   * associated property key is a symbol. `false` otherwise.
   */
  readonly hasSymbolicKey: boolean

  /**
   * `true` if this value is the value of one of the properties of a non-primitive value that is
   * enumerable. `false` otherwise.
   */
  readonly isEnumerable: boolean

  /** @internal */
  readonly [_TypeId]: {
    readonly _V: Types.Covariant<V>
  }
}

export declare const moduleTag: "@parischap/pretty-print/Value/"