export declare const ByteArray: Schema.Struct<{ bytes: Schema.filter<Schema.Schema<string, string, never>> }>

export interface ByteArray {
  readonly bytes: string
}

export declare const Constr: Schema.Struct<{
  constructor: typeof Schema.Number
  fields: Schema.Array$<Schema.suspend<Data, Data, never>>
}>

export interface Constr {
  readonly constructor: number
  readonly fields: ReadonlyArray<Data>
}

export declare const Data: Schema.Schema<Data, Data, never>

export type Data = Integer | ByteArray | List | Map | Constr

export declare const Integer: Schema.Struct<{ int: typeof Schema.Number }>

export interface Integer {
  readonly int: number
}

export declare const List: Schema.Array$<Schema.suspend<Data, Data, never>>

export interface List extends ReadonlyArray<Data> {}

export declare const Map: Schema.Record$<typeof Schema.String, Schema.suspend<Data, Data, never>>

export type Map = {
  readonly [key: string]: Data
}

export declare const isByteArray: (
  u: unknown,
  overrideOptions?: ParseOptions | number
) => u is { readonly bytes: string }

export declare const isConstr: (
  u: unknown,
  overrideOptions?: ParseOptions | number
) => u is { readonly fields: readonly Data[]; readonly constructor: number }

export declare const isInteger: (u: unknown, overrideOptions?: ParseOptions | number) => u is { readonly int: number }

export declare const isList: (u: unknown, overrideOptions?: ParseOptions | number) => u is readonly Data[]

export declare const isMap: (u: unknown, overrideOptions?: ParseOptions | number) => u is { readonly [x: string]: Data }

export interface mkConstr<T extends Data> {
  readonly constructor: number
  readonly fields: ReadonlyArray<T>
}