/* tslint:disable */
/* eslint-disable */
/**
*/
export function initialize(): void;
/**
* @returns {any}
*/
export function layouts(): any;
/**
* A block under construction.
*/
export class Block {
  free(): void;
/**
* Start building a block.
*/
  constructor();
/**
* Add an instruction getting the element of `arr` at index `idx`, and return its variable ID.
*
* Assumes `arr` and `idx` are valid variable IDs, that `idx` matches up with `arr`'s `index`
* type, and that `arr`'s `elem` type is `t`.
* @param {FuncBuilder} f
* @param {number} t
* @param {number} arr
* @param {number} idx
* @returns {number}
*/
  index(f: FuncBuilder, t: number, arr: number, idx: number): number;
/**
* Add an instruction getting member `mem` of `x`, and return its variable ID.
*
* Assumes `x` is a valid variable ID, that `mem` is a valid member ID for `x`'s struct type,
* and that the type of that member is `t`.
* @param {FuncBuilder} f
* @param {number} t
* @param {number} x
* @param {number} mem
* @returns {number}
*/
  member(f: FuncBuilder, t: number, x: number, mem: number): number;
/**
* Return the variable ID for a new boolean negation instruction on `arg`.
*
* Assumes `arg` is defined, in scope, and has boolean type.
* @param {FuncBuilder} f
* @param {number} arg
* @returns {number}
*/
  not(f: FuncBuilder, arg: number): number;
/**
* Return the variable ID for a new index modulus instruction on `arg`.
*
* Assumes `arg` is defined, in scope, and has boolean type.
* @param {FuncBuilder} f
* @param {number} t
* @param {number} arg
* @returns {number}
*/
  imod(f: FuncBuilder, t: number, arg: number): number;
/**
* Return the variable ID for a new absolute value instruction on `arg`.
*
* Assumes `arg` is defined, in scope, and has 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} arg
* @returns {number}
*/
  abs(f: FuncBuilder, arg: number): number;
/**
* Return the variable ID for a new signum instruction on `arg`.
*
* Assumes `arg` is defined, in scope, and has 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} arg
* @returns {number}
*/
  sign(f: FuncBuilder, arg: number): number;
/**
* Return the variable ID for a new ceiling instruction on `arg`.
*
* Assumes `arg` is defined, in scope, and has 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} arg
* @returns {number}
*/
  ceil(f: FuncBuilder, arg: number): number;
/**
* Return the variable ID for a new floor instruction on `arg`.
*
* Assumes `arg` is defined, in scope, and has 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} arg
* @returns {number}
*/
  floor(f: FuncBuilder, arg: number): number;
/**
* Return the variable ID for a new truncate instruction on `arg`.
*
* Assumes `arg` is defined, in scope, and has 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} arg
* @returns {number}
*/
  trunc(f: FuncBuilder, arg: number): number;
/**
* Return the variable ID for a new square root instruction on `arg`.
*
* Assumes `arg` is defined, in scope, and has 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} arg
* @returns {number}
*/
  sqrt(f: FuncBuilder, arg: number): number;
/**
* Return the variable ID for a new logical conjunction instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have boolean type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  and(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new logical disjunction instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have boolean type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  or(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new boolean equality instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have boolean type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  iff(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new exclusive disjunction instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have boolean type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  xor(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "index not equal" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have the same `Fin` type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  ineq(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "index less than" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have the same `Fin` type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  ilt(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "index less than or equal" instruction on `left` and
* `right`.
*
* Assumes `left` and `right` are defined, in scope, and have the same `Fin` type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  ileq(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "index equal" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have the same `Fin` type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  ieq(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "index greater than" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have the same `Fin` type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  igt(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "index greater than or equal" instruction on `left` and
* `right`.
*
* Assumes `left` and `right` are defined, in scope, and have the same `Fin` type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  igeq(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "index add" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have the same `Fin` type.
* @param {FuncBuilder} f
* @param {number} t
* @param {number} left
* @param {number} right
* @returns {number}
*/
  iadd(f: FuncBuilder, t: number, left: number, right: number): number;
/**
* Return the variable ID for a new "not equal" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  neq(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "less than" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  lt(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "less than or equal" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  leq(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "equal" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  eq(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "greater than" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  gt(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new "greater than or equal" instruction on `left` and `right`.
*
* Assumes `left` and `right` are defined, in scope, and have 64-bit floating point type.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  geq(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new instruction using `cond` to choose `then` or `els`.
*
* Assumes `cond`, `then`, and `els` are defined and in scope, that `cond` has boolean type,
* and that `then` and `els` both have type `t`.
* @param {FuncBuilder} f
* @param {number} cond
* @param {number} t
* @param {number} then
* @param {number} els
* @returns {number}
*/
  select(f: FuncBuilder, cond: number, t: number, then: number, els: number): number;
/**
* Return the variable ID for a new instruction calling `g` with `generics` and `args`.
*
* Assumes that `generics` are all valid type IDs, and have the right length and constraints;
* that `args` are all valid variable IDs and match up with `g`'s parameter types; and that the
* return type of `g` matches `t` (all in the context of the given `generics`).
* @param {FuncBuilder} f
* @param {Func} g
* @param {Uint32Array} generics
* @param {number} t
* @param {Uint32Array} args
* @returns {number}
*/
  call(f: FuncBuilder, g: Func, generics: Uint32Array, t: number, args: Uint32Array): number;
/**
* Return the variable ID for a new instruction defining an array elementwise via `body`.
*
* Assumes `arg` is defined and in scope; this represents the index variable for the element
* definition body, so its dependencies are prepended to the body code and it is marked as
* expired. Also assumes `out` is defined by `body`; this represents the final variable
* defining each array element. Finally, assumes the type of the array (not the element)
* matches `t`.
* @param {FuncBuilder} f
* @param {number} t
* @param {number} arg
* @param {Block} body
* @param {number} out
* @returns {number}
*/
  vec(f: FuncBuilder, t: number, arg: number, body: Block, out: number): number;
/**
* Return the variable ID for a new instruction defining an accumulator with the given `shape`.
*
* Assumes `shape` is defined and in scope, and that `t` is the ID of a reference type whose
* inner type is the same as the type of `shape`.
* @param {FuncBuilder} f
* @param {number} t
* @param {number} shape
* @returns {number}
*/
  accum(f: FuncBuilder, t: number, shape: number): number;
/**
* Return the variable ID for a new instruction accumulating `addend` into `accum`.
*
* Assumes `accum` and `addend` are defined and in scope.
* @param {FuncBuilder} f
* @param {number} accum
* @param {number} addend
* @returns {number}
*/
  addTo(f: FuncBuilder, accum: number, addend: number): number;
/**
* Return the variable ID for a new instruction resolving the given accumulator `var`.
*
* Assumes `var` is defined and in scope, and that `t` is the inner type of the reference type
* for `var`.
* @param {FuncBuilder} f
* @param {number} t
* @param {number} _var
* @returns {number}
*/
  resolve(f: FuncBuilder, t: number, _var: number): number;
/**
* Return the variable ID for a new floating-point negation instruction on `arg`.
*
* `Err` if `arg` is undefined or out of scope, or if its type is not `F64` or `T64`.
* @param {FuncBuilder} f
* @param {number} arg
* @returns {number}
*/
  neg(f: FuncBuilder, arg: number): number;
/**
* Return the variable ID for a new addition instruction on `left` and `right`.
*
* `Err` if `left` or `right` is undefined or out of scope, or if their types are not either
* both `F64` or both `T64`.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  add(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new subtraction instruction on `left` and `right`.
*
* `Err` if `left` or `right` is undefined or out of scope, or if their types are not either
* both `F64` or both `T64`.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  sub(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new multiplication instruction on `left` and `right`.
*
* `Err` if `left` or `right` is undefined or out of scope, or if `left`'s type is not `F64` or
* `T64`, or if `right`'s type is not `F64`.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  mul(f: FuncBuilder, left: number, right: number): number;
/**
* Return the variable ID for a new division instruction on `left` and `right`.
*
* `Err` if `left` or `right` is undefined or out of scope, or if `left`'s type is not `F64` or
* `T64`, or if `right`'s type is not `F64`.
* @param {FuncBuilder} f
* @param {number} left
* @param {number} right
* @returns {number}
*/
  div(f: FuncBuilder, left: number, right: number): number;
}
/**
* A node in a reference-counted acyclic digraph of functions.
*/
export class Func {
  free(): void;
/**
* Return an opaque function taking `params` `F64` parameters and returning `F64`.
* @param {number} params
* @param {Function} def
*/
  constructor(params: number, def: Function);
/**
* @returns {string}
*/
  pprint(): string;
/**
* Return the IDs of this function's parameter types.
* @returns {Uint32Array}
*/
  paramTypes(): Uint32Array;
/**
* Return the ID of this function's return type.
* @returns {number}
*/
  retType(): number;
/**
* Return the number of types defined in this function.
* @returns {number}
*/
  numTypes(): number;
/**
* Return true iff `t` is the ID of a unit type.
* @param {number} t
* @returns {boolean}
*/
  isUnit(t: number): boolean;
/**
* Return true iff `t` is the ID of a boolean type.
* @param {number} t
* @returns {boolean}
*/
  isBool(t: number): boolean;
/**
* Return true iff `t` is the ID of a 64-bit floating-point type.
* @param {number} t
* @returns {boolean}
*/
  isF64(t: number): boolean;
/**
* Return true iff `t` is the ID of a finite integer type.
* @param {number} t
* @returns {boolean}
*/
  isFin(t: number): boolean;
/**
* Return true iff `t` is the ID of an array type.
* @param {number} t
* @returns {boolean}
*/
  isArray(t: number): boolean;
/**
* Return true iff `t` is the ID of a struct type.
* @param {number} t
* @returns {boolean}
*/
  isStruct(t: number): boolean;
/**
* Return the size of the finite integer type with ID `t`.
* @param {number} t
* @returns {number}
*/
  size(t: number): number;
/**
* Return the ID of the index type for the array type with ID `t`.
* @param {number} t
* @returns {number}
*/
  index(t: number): number;
/**
* Return the ID of the element type for the array type with ID `t`.
* @param {number} t
* @returns {number}
*/
  elem(t: number): number;
/**
* Return the string IDs for the struct type with ID `t`.
* @param {number} t
* @returns {Uint32Array}
*/
  keys(t: number): Uint32Array;
/**
* Return the member type IDs for the struct type with ID `t`.
* @param {number} t
* @returns {Uint32Array}
*/
  mems(t: number): Uint32Array;
/**
* Interpret a function with no generics or parameters.
*
* The `args` are Serde-converted to `Vec<rose_interp::Val>`, and the return value is
* Serde-converted from `rose_interp::Val`.
* @param {any} args
* @returns {any}
*/
  interp(args: any): any;
/**
* Compile the call graph subtended by this function to WebAssembly.
* @returns {Wasm}
*/
  compile(): Wasm;
/**
* Set the JVP of this function to `f`.
* @param {Func} f
*/
  setJvp(f: Func): void;
/**
* Return a function that computes the Jacobian-vector product of this function.
*
* `re` must be the string ID for the string `"re"` not just in this function, but in every
* function that this function calls, and so on, transitively. Same for `du` and `"du"`.
* @param {number} re
* @param {number} du
* @returns {Func}
*/
  jvp(re: number, du: number): Func;
/**
* Return the transpose of this function.
*
* Assumes that this function has already been computed as the `jvp` of another function.
* @returns {Transpose}
*/
  transpose(): Transpose;
}
/**
* A function under construction.
*/
export class FuncBuilder {
  free(): void;
/**
* Start building a function with the given number of `generics`, all constrained as `Index`.
* @param {number} generics
*/
  constructor(generics: number);
/**
* Assemble this function with return variable `out` and the given `body`.
* @param {number} out
* @param {Block} body
* @returns {Func}
*/
  finish(out: number, body: Block): Func;
/**
* Should the type with ID `t` be represented as a JavaScript `Symbol`?
*
* Values of index types must be symbols so that we can use the standard JavaScript indexing
* notation (along with `Proxy`, see below) to generate array accessing code.
* @param {number} t
* @returns {boolean}
*/
  isSymbol(t: number): boolean;
/**
* Is the type with ID `t` an array that should be represented as a JavaScript `Proxy`?
*
* Values of array types must be proxies so that we can use the standard JavaScript indexing
* notation (along with `Symbol`, see above) to generate array accessing code.
* @param {number} t
* @returns {boolean}
*/
  isArray(t: number): boolean;
/**
* Is the type with ID `t` a struct that should be represented as a JavaScript `Proxy`?
*
* Values of struct types must be proxies so that we can use the standard JavaScript property
* access notation to generate member accessing code.
* @param {number} t
* @returns {boolean}
*/
  isStruct(t: number): boolean;
/**
* Return the ID of the index type for the array type with ID `t`.
*
* `Err` if `t` is out of range or does not represent an array type.
* @param {number} t
* @returns {number}
*/
  index(t: number): number;
/**
* Return the number of elements for the array type with ID `t`.
*
* `Err` if `t` is out of range or does not represent an array type, or if its index type is
* not a fixed size (e.g. if it is a generic type parameter of the function).
* @param {number} t
* @returns {number}
*/
  size(t: number): number;
/**
* Return the ID of the element type for the array type with ID `t`.
*
* `Err` if `t` is out of range or does not represent an array type.
* @param {number} t
* @returns {number}
*/
  elem(t: number): number;
/**
* Return the string IDs of the keys for the struct type with ID `t`.
*
* `Err` if `t` is out of range or does not represent a struct type.
* @param {number} t
* @returns {Uint32Array}
*/
  keys(t: number): Uint32Array;
/**
* Return the type IDs of the members for the struct type with ID `t`.
*
* `Err` if `t` is out of range or does not represent a struct type.
* @param {number} t
* @returns {Uint32Array}
*/
  members(t: number): Uint32Array;
/**
* Return `x` if it exists, is in scope, and has type ID `t`; `Err` otherwise.
* @param {number} t
* @param {number} x
* @returns {number}
*/
  expect(t: number, x: number): number;
/**
* Return the ID for the unit type, creating if needed.
* @returns {number}
*/
  tyUnit(): number;
/**
* Return the ID for the boolean type, creating if needed.
* @returns {number}
*/
  tyBool(): number;
/**
* Return the ID for the 64-bit floating-point type, creating if needed.
* @returns {number}
*/
  tyF64(): number;
/**
* Return the ID for the 64-bit floating-point tangent type, creating if needed.
* @returns {number}
*/
  tyT64(): number;
/**
* Return the ID for the type of nonnegative integers less than `size`, creating if needed.
* @param {number} size
* @returns {number}
*/
  tyFin(size: number): number;
/**
* @param {number} inner
* @returns {number}
*/
  tyRef(inner: number): number;
/**
* Return the ID for the type of arrays with index type `index` and element type `elem`,
*
* Assumes `index` and `elem` are valid type IDs.
* @param {number} index
* @param {number} elem
* @returns {number}
*/
  tyArray(index: number, elem: number): number;
/**
* Return the ID fr the type of structs with key string IDs `keys` and member type IDs `mems`.
*
* Assumes `keys` are valid string IDs and `mems` are valid type IDs.
* @param {Uint32Array} keys
* @param {Uint32Array} mems
* @returns {number}
*/
  tyStruct(keys: Uint32Array, mems: Uint32Array): number;
/**
* Return the ID of a new variable with type ID `t`.
* @param {number} t
* @returns {number}
*/
  bind(t: number): number;
/**
* Append a parameter with type ID `t` and return its variable ID.
* @param {number} t
* @returns {number}
*/
  param(t: number): number;
/**
* Create a constant variable with the unit type, and return its ID.
*
* `Err` if `t` is not the ID of the unit type.
* @param {number} t
* @returns {number}
*/
  unit(t: number): number;
/**
* Create a constant variable with the boolean type and value `val`, and return its ID.
*
* `Err` if `t` is not the ID of the boolean type.
* @param {number} t
* @param {boolean} val
* @returns {number}
*/
  bool(t: number, val: boolean): number;
/**
* Return the ID of a new numeric constant variable with type `t` and value converted from `x`.
*
* `Err` unless `t` is the ID of either the 64-bit floating-point type or a finite nonnegative
* integer type; or if `t` is an integer type which cannot represent the given value of `x`.
* @param {number} t
* @param {number} x
* @returns {number}
*/
  num(t: number, x: number): number;
/**
* Return the ID of a new array variable with type ID `t` and elements `xs`.
*
* Assumes that `t` is a valid type ID and `xs` are all valid variable IDs. If there are no
* dependencies on parameters then the new array variable is a constant; otherwise, it is
* attached to whichever parent variable reachable from `xs` has the highest ID.
* @param {number} t
* @param {Uint32Array} xs
* @returns {number}
*/
  array(t: number, xs: Uint32Array): number;
/**
* Return the ID of a new struct variable with type ID `t` and elements `xs`.
*
* Assumes that `t` is a valid type ID and `xs` are all valid variable IDs. If there are no
* dependencies on parameters then the new struct variable is a constant; otherwise, it is
* attached to whichever parent variable reachable from `xs` has the highest ID.
* @param {number} t
* @param {Uint32Array} xs
* @returns {number}
*/
  obj(t: number, xs: Uint32Array): number;
/**
* Return the parameter and return type IDs in this function for calling `f` with `generics`.
*
* Assumes `generics` are all valid type IDs, and have the right length and constraints.
*
* The returned `Vec` is always nonempty, since its last element is the return type; all the
* other elements are the parameter types.
* @param {Func} f
* @param {Uint32Array} strings
* @param {Uint32Array} generics
* @returns {Uint32Array}
*/
  ingest(f: Func, strings: Uint32Array, generics: Uint32Array): Uint32Array;
}
/**
* A temporary object to hold the two passes of a transposed function before they are destructured.
*/
export class Transpose {
  free(): void;
/**
* Return the forward pass.
* @returns {Func | undefined}
*/
  fwd(): Func | undefined;
/**
* Return the backward pass.
* @returns {Func | undefined}
*/
  bwd(): Func | undefined;
}
/**
* A temporary object to hold a generated WebAssembly module and its imports.
*/
export class Wasm {
  free(): void;
/**
* Return the module binary.
* @returns {Uint8Array | undefined}
*/
  bytes(): Uint8Array | undefined;
/**
* Return the imports.
* @returns {(Function)[] | undefined}
*/
  imports(): (Function)[] | undefined;
/**
*/
  pages: bigint;
}

export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;

export interface InitOutput {
  readonly memory: WebAssembly.Memory;
  readonly initialize: () => void;
  readonly layouts: (a: number) => void;
  readonly __wbg_func_free: (a: number) => void;
  readonly func_new: (a: number, b: number) => number;
  readonly func_pprint: (a: number, b: number) => void;
  readonly func_paramTypes: (a: number, b: number) => void;
  readonly func_retType: (a: number) => number;
  readonly func_numTypes: (a: number) => number;
  readonly func_isUnit: (a: number, b: number) => number;
  readonly func_isBool: (a: number, b: number) => number;
  readonly func_isF64: (a: number, b: number) => number;
  readonly func_isFin: (a: number, b: number) => number;
  readonly func_isArray: (a: number, b: number) => number;
  readonly func_isStruct: (a: number, b: number) => number;
  readonly func_size: (a: number, b: number) => number;
  readonly func_index: (a: number, b: number) => number;
  readonly func_elem: (a: number, b: number) => number;
  readonly func_keys: (a: number, b: number, c: number) => void;
  readonly func_mems: (a: number, b: number, c: number) => void;
  readonly func_interp: (a: number, b: number, c: number) => void;
  readonly func_compile: (a: number) => number;
  readonly func_setJvp: (a: number, b: number) => void;
  readonly func_jvp: (a: number, b: number, c: number) => number;
  readonly func_transpose: (a: number) => number;
  readonly __wbg_wasm_free: (a: number) => void;
  readonly __wbg_get_wasm_pages: (a: number) => number;
  readonly __wbg_set_wasm_pages: (a: number, b: number) => void;
  readonly wasm_bytes: (a: number, b: number) => void;
  readonly wasm_imports: (a: number, b: number) => void;
  readonly __wbg_transpose_free: (a: number) => void;
  readonly transpose_fwd: (a: number) => number;
  readonly transpose_bwd: (a: number) => number;
  readonly __wbg_funcbuilder_free: (a: number) => void;
  readonly funcbuilder_new: (a: number) => number;
  readonly funcbuilder_finish: (a: number, b: number, c: number) => number;
  readonly funcbuilder_isSymbol: (a: number, b: number) => number;
  readonly funcbuilder_isArray: (a: number, b: number) => number;
  readonly funcbuilder_isStruct: (a: number, b: number) => number;
  readonly funcbuilder_index: (a: number, b: number, c: number) => void;
  readonly funcbuilder_size: (a: number, b: number, c: number) => void;
  readonly funcbuilder_elem: (a: number, b: number, c: number) => void;
  readonly funcbuilder_keys: (a: number, b: number, c: number) => void;
  readonly funcbuilder_members: (a: number, b: number, c: number) => void;
  readonly funcbuilder_expect: (a: number, b: number, c: number, d: number) => void;
  readonly funcbuilder_tyUnit: (a: number) => number;
  readonly funcbuilder_tyBool: (a: number) => number;
  readonly funcbuilder_tyF64: (a: number) => number;
  readonly funcbuilder_tyT64: (a: number) => number;
  readonly funcbuilder_tyFin: (a: number, b: number) => number;
  readonly funcbuilder_tyRef: (a: number, b: number) => number;
  readonly funcbuilder_tyArray: (a: number, b: number, c: number, d: number) => void;
  readonly funcbuilder_tyStruct: (a: number, b: number, c: number, d: number, e: number) => number;
  readonly funcbuilder_bind: (a: number, b: number) => number;
  readonly funcbuilder_param: (a: number, b: number) => number;
  readonly funcbuilder_unit: (a: number, b: number, c: number) => void;
  readonly funcbuilder_bool: (a: number, b: number, c: number, d: number) => void;
  readonly funcbuilder_num: (a: number, b: number, c: number, d: number) => void;
  readonly funcbuilder_array: (a: number, b: number, c: number, d: number) => number;
  readonly funcbuilder_obj: (a: number, b: number, c: number, d: number) => number;
  readonly funcbuilder_ingest: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
  readonly __wbg_block_free: (a: number) => void;
  readonly block_new: () => number;
  readonly block_index: (a: number, b: number, c: number, d: number, e: number) => number;
  readonly block_member: (a: number, b: number, c: number, d: number, e: number) => number;
  readonly block_not: (a: number, b: number, c: number) => number;
  readonly block_imod: (a: number, b: number, c: number, d: number) => number;
  readonly block_abs: (a: number, b: number, c: number) => number;
  readonly block_sign: (a: number, b: number, c: number) => number;
  readonly block_ceil: (a: number, b: number, c: number) => number;
  readonly block_floor: (a: number, b: number, c: number) => number;
  readonly block_trunc: (a: number, b: number, c: number) => number;
  readonly block_sqrt: (a: number, b: number, c: number) => number;
  readonly block_and: (a: number, b: number, c: number, d: number) => number;
  readonly block_or: (a: number, b: number, c: number, d: number) => number;
  readonly block_iff: (a: number, b: number, c: number, d: number) => number;
  readonly block_xor: (a: number, b: number, c: number, d: number) => number;
  readonly block_ineq: (a: number, b: number, c: number, d: number) => number;
  readonly block_ilt: (a: number, b: number, c: number, d: number) => number;
  readonly block_ileq: (a: number, b: number, c: number, d: number) => number;
  readonly block_ieq: (a: number, b: number, c: number, d: number) => number;
  readonly block_igt: (a: number, b: number, c: number, d: number) => number;
  readonly block_igeq: (a: number, b: number, c: number, d: number) => number;
  readonly block_iadd: (a: number, b: number, c: number, d: number, e: number) => number;
  readonly block_neq: (a: number, b: number, c: number, d: number) => number;
  readonly block_lt: (a: number, b: number, c: number, d: number) => number;
  readonly block_leq: (a: number, b: number, c: number, d: number) => number;
  readonly block_eq: (a: number, b: number, c: number, d: number) => number;
  readonly block_gt: (a: number, b: number, c: number, d: number) => number;
  readonly block_geq: (a: number, b: number, c: number, d: number) => number;
  readonly block_select: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
  readonly block_call: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
  readonly block_vec: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
  readonly block_accum: (a: number, b: number, c: number, d: number) => number;
  readonly block_addTo: (a: number, b: number, c: number, d: number) => number;
  readonly block_resolve: (a: number, b: number, c: number, d: number) => number;
  readonly block_neg: (a: number, b: number, c: number, d: number) => void;
  readonly block_add: (a: number, b: number, c: number, d: number, e: number) => void;
  readonly block_sub: (a: number, b: number, c: number, d: number, e: number) => void;
  readonly block_mul: (a: number, b: number, c: number, d: number, e: number) => void;
  readonly block_div: (a: number, b: number, c: number, d: number, e: number) => void;
  readonly __wbindgen_malloc: (a: number, b: number) => number;
  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
  readonly __wbindgen_exn_store: (a: number) => void;
}

export type SyncInitInput = BufferSource | WebAssembly.Module;
/**
* Instantiates the given `module`, which can either be bytes or
* a precompiled `WebAssembly.Module`.
*
* @param {SyncInitInput} module
*
* @returns {InitOutput}
*/
export function initSync(module: SyncInitInput): InitOutput;

/**
* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
* for everything else, calls `WebAssembly.instantiate` directly.
*
* @param {InitInput | Promise<InitInput>} module_or_path
*
* @returns {Promise<InitOutput>}
*/
export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;