Direct (mina_base.Mina_base.Zkapp_account.Poly.Fields.Direct)

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

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

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

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

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

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

val set_all_mutable_fields : 'a -> unit