Fields (mina_base.Mina_base.Zkapp_account.Poly.Stable.V2.Fields)

val names : string list

val zkapp_uri : 
  ( [< `Read | `Set_and_create ],
    ( 'a, 'b, 'c, 'd, 'e, 'f, 'zkapp_uri ) t,
    'zkapp_uri0 )
    Fieldslib.Field.t_with_perm

val proved_state : 
  ( [< `Read | `Set_and_create ], ( 'a, 'b, 'c, 'd, 'e, 'bool, 'f ) t, 'bool0 )
    Fieldslib.Field.t_with_perm

val last_sequence_slot : 
  ( [< `Read | `Set_and_create ], ( 'a, 'b, 'c, 'd, 'slot, 'e, 'f ) t, 'slot0 )
    Fieldslib.Field.t_with_perm

val sequence_state : 
  ( [< `Read | `Set_and_create ],
    ( 'a, 'b, 'c, 'field, 'd, 'e, 'f ) t,
    'field0 Pickles_types.Vector.Vector_5.Stable.V1.t )
    Fieldslib.Field.t_with_perm

val zkapp_version : 
  ( [< `Read | `Set_and_create ],
    ( 'a, 'b, 'zkapp_version, 'c, 'd, 'e, 'f ) t,
    'zkapp_version0 )
    Fieldslib.Field.t_with_perm

val verification_key : 
  ( [< `Read | `Set_and_create ], ( 'a, 'vk, 'b, 'c, 'd, 'e, 'f ) t, 'vk0 )
    Fieldslib.Field.t_with_perm

val app_state : 
  ( [< `Read | `Set_and_create ],
    ( 'app_state, 'a, 'b, 'c, 'd, 'e, 'f ) t,
    'app_state0 )
    Fieldslib.Field.t_with_perm

val make_creator : 
  app_state:
    ( ( [< `Read | `Set_and_create ], ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t, 'a )
        Fieldslib.Field.t_with_perm ->
      'h ->
      ( 'i -> 'j ) * 'k ) ->
  verification_key:
    ( ( [< `Read | `Set_and_create ], ( 'l, 'm, 'n, 'o, 'p, 'q, 'r ) t, 'm )
        Fieldslib.Field.t_with_perm ->
      's ->
      ( 't -> 'u ) * 'v ) ->
  zkapp_version:
    ( ( [< `Read | `Set_and_create ], ( 'w, 'x, 'y, 'z, 'a1, 'b1, 'c1 ) t, 'y )
        Fieldslib.Field.t_with_perm ->
      'd1 ->
      ( 'e1 -> 'f1 ) * 'g1 ) ->
  sequence_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'h1, 'i1, 'j1, 'k1, 'l1, 'm1, 'n1 ) t,
        'k1 Pickles_types.Vector.Vector_5.Stable.V1.t )
        Fieldslib.Field.t_with_perm ->
      'o1 ->
      ( 'p1 -> 'q1 Pickles_types.Vector.Vector_5.Stable.V1.t ) * 'r1 ) ->
  last_sequence_slot:
    ( ( [< `Read | `Set_and_create ],
        ( 's1, 't1, 'u1, 'v1, 'w1, 'x1, 'y1 ) t,
        'w1 )
        Fieldslib.Field.t_with_perm ->
      'z1 ->
      ( 'a2 -> 'b2 ) * 'c2 ) ->
  proved_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'd2, 'e2, 'f2, 'g2, 'h2, 'i2, 'j2 ) t,
        'i2 )
        Fieldslib.Field.t_with_perm ->
      'k2 ->
      ( 'l2 -> 'm2 ) * 'n2 ) ->
  zkapp_uri:
    ( ( [< `Read | `Set_and_create ],
        ( 'o2, 'p2, 'q2, 'r2, 's2, 't2, 'u2 ) t,
        'u2 )
        Fieldslib.Field.t_with_perm ->
      'v2 ->
      ( 'w2 -> 'x2 ) * 'y2 ) ->
  'z2 ->
  ( 'a3 -> ( 'b3, 'c3, 'd3, 'e3, 'f3, 'g3, 'h3 ) t ) * 'i3

val create : 
  app_state:'a ->
  verification_key:'b ->
  zkapp_version:'c ->
  sequence_state:'d Pickles_types.Vector.Vector_5.Stable.V1.t ->
  last_sequence_slot:'e ->
  proved_state:'f ->
  zkapp_uri:'g ->
  ( 'h, 'i, 'j, 'k, 'l, 'm, 'n ) t

val map : 
  app_state:
    ( ( [< `Read | `Set_and_create ], ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t, 'a )
        Fieldslib.Field.t_with_perm ->
      'h ) ->
  verification_key:
    ( ( [< `Read | `Set_and_create ], ( 'i, 'j, 'k, 'l, 'm, 'n, 'o ) t, 'j )
        Fieldslib.Field.t_with_perm ->
      'p ) ->
  zkapp_version:
    ( ( [< `Read | `Set_and_create ], ( 'q, 'r, 's, 't, 'u, 'v, 'w ) t, 's )
        Fieldslib.Field.t_with_perm ->
      'x ) ->
  sequence_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'y, 'z, 'a1, 'b1, 'c1, 'd1, 'e1 ) t,
        'b1 Pickles_types.Vector.Vector_5.Stable.V1.t )
        Fieldslib.Field.t_with_perm ->
      'f1 Pickles_types.Vector.Vector_5.Stable.V1.t ) ->
  last_sequence_slot:
    ( ( [< `Read | `Set_and_create ],
        ( 'g1, 'h1, 'i1, 'j1, 'k1, 'l1, 'm1 ) t,
        'k1 )
        Fieldslib.Field.t_with_perm ->
      'n1 ) ->
  proved_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'o1, 'p1, 'q1, 'r1, 's1, 't1, 'u1 ) t,
        't1 )
        Fieldslib.Field.t_with_perm ->
      'v1 ) ->
  zkapp_uri:
    ( ( [< `Read | `Set_and_create ],
        ( 'w1, 'x1, 'y1, 'z1, 'a2, 'b2, 'c2 ) t,
        'c2 )
        Fieldslib.Field.t_with_perm ->
      'd2 ) ->
  ( 'e2, 'f2, 'g2, 'h2, 'i2, 'j2, 'k2 ) t

val iter : 
  app_state:
    ( ( [< `Read | `Set_and_create ], ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t, 'a )
        Fieldslib.Field.t_with_perm ->
      unit ) ->
  verification_key:
    ( ( [< `Read | `Set_and_create ], ( 'h, 'i, 'j, 'k, 'l, 'm, 'n ) t, 'i )
        Fieldslib.Field.t_with_perm ->
      unit ) ->
  zkapp_version:
    ( ( [< `Read | `Set_and_create ], ( 'o, 'p, 'q, 'r, 's, 't, 'u ) t, 'q )
        Fieldslib.Field.t_with_perm ->
      unit ) ->
  sequence_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'v, 'w, 'x, 'y, 'z, 'a1, 'b1 ) t,
        'y Pickles_types.Vector.Vector_5.Stable.V1.t )
        Fieldslib.Field.t_with_perm ->
      unit ) ->
  last_sequence_slot:
    ( ( [< `Read | `Set_and_create ],
        ( 'c1, 'd1, 'e1, 'f1, 'g1, 'h1, 'i1 ) t,
        'g1 )
        Fieldslib.Field.t_with_perm ->
      unit ) ->
  proved_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'j1, 'k1, 'l1, 'm1, 'n1, 'o1, 'p1 ) t,
        'o1 )
        Fieldslib.Field.t_with_perm ->
      unit ) ->
  zkapp_uri:
    ( ( [< `Read | `Set_and_create ],
        ( 'q1, 'r1, 's1, 't1, 'u1, 'v1, 'w1 ) t,
        'w1 )
        Fieldslib.Field.t_with_perm ->
      unit ) ->
  unit

val fold : 
  init:'a ->
  app_state:
    ( 'b ->
      ( [< `Read | `Set_and_create ], ( 'c, 'd, 'e, 'f, 'g, 'h, 'i ) t, 'c )
        Fieldslib.Field.t_with_perm ->
      'j ) ->
  verification_key:
    ( 'k ->
      ( [< `Read | `Set_and_create ], ( 'l, 'm, 'n, 'o, 'p, 'q, 'r ) t, 'm )
        Fieldslib.Field.t_with_perm ->
      's ) ->
  zkapp_version:
    ( 't ->
      ( [< `Read | `Set_and_create ], ( 'u, 'v, 'w, 'x, 'y, 'z, 'a1 ) t, 'w )
        Fieldslib.Field.t_with_perm ->
      'b1 ) ->
  sequence_state:
    ( 'c1 ->
      ( [< `Read | `Set_and_create ],
        ( 'd1, 'e1, 'f1, 'g1, 'h1, 'i1, 'j1 ) t,
        'g1 Pickles_types.Vector.Vector_5.Stable.V1.t )
        Fieldslib.Field.t_with_perm ->
      'k1 ) ->
  last_sequence_slot:
    ( 'l1 ->
      ( [< `Read | `Set_and_create ],
        ( 'm1, 'n1, 'o1, 'p1, 'q1, 'r1, 's1 ) t,
        'q1 )
        Fieldslib.Field.t_with_perm ->
      't1 ) ->
  proved_state:
    ( 'u1 ->
      ( [< `Read | `Set_and_create ],
        ( 'v1, 'w1, 'x1, 'y1, 'z1, 'a2, 'b2 ) t,
        'a2 )
        Fieldslib.Field.t_with_perm ->
      'c2 ) ->
  zkapp_uri:
    ( 'd2 ->
      ( [< `Read | `Set_and_create ],
        ( 'e2, 'f2, 'g2, 'h2, 'i2, 'j2, 'k2 ) t,
        'k2 )
        Fieldslib.Field.t_with_perm ->
      'l2 ) ->
  'm2

val map_poly : 
  ( [< `Read | `Set_and_create ], ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t, 'h )
    Fieldslib.Field.user ->
  'i list

val for_all : 
  app_state:
    ( ( [< `Read | `Set_and_create ], ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t, 'a )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  verification_key:
    ( ( [< `Read | `Set_and_create ], ( 'h, 'i, 'j, 'k, 'l, 'm, 'n ) t, 'i )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  zkapp_version:
    ( ( [< `Read | `Set_and_create ], ( 'o, 'p, 'q, 'r, 's, 't, 'u ) t, 'q )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  sequence_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'v, 'w, 'x, 'y, 'z, 'a1, 'b1 ) t,
        'y Pickles_types.Vector.Vector_5.Stable.V1.t )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  last_sequence_slot:
    ( ( [< `Read | `Set_and_create ],
        ( 'c1, 'd1, 'e1, 'f1, 'g1, 'h1, 'i1 ) t,
        'g1 )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  proved_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'j1, 'k1, 'l1, 'm1, 'n1, 'o1, 'p1 ) t,
        'o1 )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  zkapp_uri:
    ( ( [< `Read | `Set_and_create ],
        ( 'q1, 'r1, 's1, 't1, 'u1, 'v1, 'w1 ) t,
        'w1 )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  bool

val exists : 
  app_state:
    ( ( [< `Read | `Set_and_create ], ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t, 'a )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  verification_key:
    ( ( [< `Read | `Set_and_create ], ( 'h, 'i, 'j, 'k, 'l, 'm, 'n ) t, 'i )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  zkapp_version:
    ( ( [< `Read | `Set_and_create ], ( 'o, 'p, 'q, 'r, 's, 't, 'u ) t, 'q )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  sequence_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'v, 'w, 'x, 'y, 'z, 'a1, 'b1 ) t,
        'y Pickles_types.Vector.Vector_5.Stable.V1.t )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  last_sequence_slot:
    ( ( [< `Read | `Set_and_create ],
        ( 'c1, 'd1, 'e1, 'f1, 'g1, 'h1, 'i1 ) t,
        'g1 )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  proved_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'j1, 'k1, 'l1, 'm1, 'n1, 'o1, 'p1 ) t,
        'o1 )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  zkapp_uri:
    ( ( [< `Read | `Set_and_create ],
        ( 'q1, 'r1, 's1, 't1, 'u1, 'v1, 'w1 ) t,
        'w1 )
        Fieldslib.Field.t_with_perm ->
      bool ) ->
  bool

val to_list : 
  app_state:
    ( ( [< `Read | `Set_and_create ], ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t, 'a )
        Fieldslib.Field.t_with_perm ->
      'h ) ->
  verification_key:
    ( ( [< `Read | `Set_and_create ], ( 'i, 'j, 'k, 'l, 'm, 'n, 'o ) t, 'j )
        Fieldslib.Field.t_with_perm ->
      'p ) ->
  zkapp_version:
    ( ( [< `Read | `Set_and_create ], ( 'q, 'r, 's, 't, 'u, 'v, 'w ) t, 's )
        Fieldslib.Field.t_with_perm ->
      'x ) ->
  sequence_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'y, 'z, 'a1, 'b1, 'c1, 'd1, 'e1 ) t,
        'b1 Pickles_types.Vector.Vector_5.Stable.V1.t )
        Fieldslib.Field.t_with_perm ->
      'f1 ) ->
  last_sequence_slot:
    ( ( [< `Read | `Set_and_create ],
        ( 'g1, 'h1, 'i1, 'j1, 'k1, 'l1, 'm1 ) t,
        'k1 )
        Fieldslib.Field.t_with_perm ->
      'n1 ) ->
  proved_state:
    ( ( [< `Read | `Set_and_create ],
        ( 'o1, 'p1, 'q1, 'r1, 's1, 't1, 'u1 ) t,
        't1 )
        Fieldslib.Field.t_with_perm ->
      'v1 ) ->
  zkapp_uri:
    ( ( [< `Read | `Set_and_create ],
        ( 'w1, 'x1, 'y1, 'z1, 'a2, 'b2, 'c2 ) t,
        'c2 )
        Fieldslib.Field.t_with_perm ->
      'd2 ) ->
  'e2 list

module Direct : sig ... end