eliom 6.9.2 · OCaml Package

type get =

| Get_method

type put =

| Put_method

type post =

| Post_method

type delete =

| Delete_method

type co =

| Co

type non_co =

| Non_co

type ext =

| Ext

type non_ext =

| Non_ext

type http =

| Http_ret

type !'a ocaml =

| Ocaml of 'a

type non_ocaml =

| Non_ocaml

type reg =

| Reg

type non_reg =

| Non_reg

type ('get, 'a, 'gn) params = ('get, 'a, 'gn) Eliom_parameter.params_type constraint 'a = [< `WithSuffix | `WithoutSuffix ]

type (!'m, !_, !_, !_, !_, !_, !_) meth =

| Get : ('gp, [< `WithSuffix | `WithoutSuffix ] as 'a, 'gn) params -> (get, 'gp, 'gn, unit, unit, 'a, unit) meth
| Post : ('gp0, [< `WithSuffix | `WithoutSuffix ] as 'b, 'gn0) params * ('pp, [ `WithoutSuffix ], 'pn) params -> (post, 'gp0, 'gn0, 'pp, 'pn, 'b, 'gp0) meth
| Put : ('gp1, [< `WithSuffix | `WithoutSuffix ] as 'c, 'gn1) params -> (put, 'gp1, 'gn1, Eliom_parameter.raw_post_data, Eliom_parameter.no_param_name, 'c, unit) meth
| Delete : ('gp2, [< `WithSuffix | `WithoutSuffix ] as 'd, 'gn2) params -> (delete, 'gp2, 'gn2, Eliom_parameter.raw_post_data, Eliom_parameter.no_param_name, 'd, unit) meth

type !'m which_meth =

| Get' : get which_meth
| Post' : post which_meth
| Put' : put which_meth
| Delete' : delete which_meth

type att

type non_att

type !'a attached_info =

| Attached : att -> att attached_info
| Nonattached : non_att -> non_att attached_info

type ('get, 'post, 'meth, 'attached, 'co, 'ext, 'reg, +'a, 'gn, 'pn, 'ret) t constraint 'a = [< `WithSuffix | `WithoutSuffix ]

and result =

| No_contents
| Dom of Js_of_ocaml.Dom_html.element Js_of_ocaml.Js.t
| Reload
| Redirect : (unit, unit, get, 'a, 'b, 'c, 'd, [ `WithoutSuffix ], unit, unit, non_ocaml) t -> result
| Reload_action of {
1. hidden : bool;
2. https : bool;
}

type (!_, !_, !_) path_option =

| Path : Eliom_lib.Url.path -> (att, non_co, 'a) path_option
| No_path : (non_att, co, unit) path_option

val reload_action : 
  (unit,
    unit,
    get,
    non_att,
    co,
    non_ext,
    non_reg,
    [ `WithoutSuffix ],
    unit,
    unit,
    non_ocaml)
    t

val reload_action_https : 
  (unit,
    unit,
    get,
    non_att,
    co,
    non_ext,
    non_reg,
    [ `WithoutSuffix ],
    unit,
    unit,
    non_ocaml)
    t

val reload_action_hidden : 
  (unit,
    unit,
    get,
    non_att,
    co,
    non_ext,
    non_reg,
    [ `WithoutSuffix ],
    unit,
    unit,
    non_ocaml)
    t

val reload_action_https_hidden : 
  (unit,
    unit,
    get,
    non_att,
    co,
    non_ext,
    non_reg,
    [ `WithoutSuffix ],
    unit,
    unit,
    non_ocaml)
    t

val static_dir : 
  unit ->
  (string list,
    unit,
    get,
    att,
    non_co,
    non_ext,
    non_reg,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name,
    unit,
    non_ocaml)
    t

val https_static_dir : 
  unit ->
  (string list,
    unit,
    get,
    att,
    non_co,
    non_ext,
    non_reg,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name,
    unit,
    non_ocaml)
    t

val static_dir_with_params : 
  ?keep_nl_params:[ `All | `None | `Persistent ] ->
  get_params:('a, [ `WithoutSuffix ], 'an) Eliom_parameter.params_type ->
  unit ->
  (string list * 'a,
    unit,
    get,
    att,
    non_co,
    non_ext,
    non_reg,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name * 'an,
    unit,
    non_ocaml)
    t

val https_static_dir_with_params : 
  ?keep_nl_params:[ `All | `None | `Persistent ] ->
  get_params:('a, [ `WithoutSuffix ], 'an) Eliom_parameter.params_type ->
  unit ->
  (string list * 'a,
    unit,
    get,
    att,
    non_co,
    non_ext,
    non_reg,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name * 'an,
    unit,
    non_ocaml)
    t

val preapply : 
  service:
    ('a,
      'b,
      'meth,
      att,
      'co,
      'ext,
      'reg,
      [< `WithSuffix | `WithoutSuffix ],
      'e,
      'f,
      'return)
      t ->
  'a ->
  (unit,
    'b,
    'meth,
    att,
    'co,
    'ext,
    non_reg,
    [ `WithoutSuffix ],
    unit,
    'f,
    'return)
    t

val add_non_localized_get_parameters : 
  params:('p, [ `WithoutSuffix ], 'pn) Eliom_parameter.non_localized_params ->
  service:
    ('a,
      'b,
      'meth,
      'attach,
      'co,
      'ext,
      'reg,
      [< `WithSuffix | `WithoutSuffix ] as 'c,
      'e,
      'f,
      'return)
      t ->
  ('a * 'p, 'b, 'meth, 'attach, 'co, 'ext, 'reg, 'c, 'e * 'pn, 'f, 'return) t

val add_non_localized_post_parameters : 
  params:('p, [ `WithoutSuffix ], 'pn) Eliom_parameter.non_localized_params ->
  service:
    ('a,
      'b,
      'meth,
      'attach,
      'co,
      'ext,
      'g,
      [< `WithSuffix | `WithoutSuffix ] as 'c,
      'e,
      'f,
      'return)
      t ->
  ('a, 'b * 'p, 'meth, 'attach, 'co, 'ext, 'g, 'c, 'e, 'f * 'pn, 'return) t

val extern : 
  ?keep_nl_params:[ `All | `None | `Persistent ] ->
  prefix:string ->
  path:Eliom_lib.Url.path ->
  meth:
    ('m, 'gp, 'gn, 'pp, 'pn, [< `WithSuffix | `WithoutSuffix ] as 'a, 'b) meth ->
  unit ->
  ('gp, 'pp, 'm, att, non_co, ext, non_reg, 'a, 'gn, 'pn, non_ocaml) t

val which_meth : 
  ('a, 'b, 'm, 'c, 'd, 'e, 'f, [< `WithSuffix | `WithoutSuffix ], 'g, 'h, 'i) t ->
  'm which_meth

val which_meth_untyped : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  [ `Delete | `Get | `Post | `Put ]

val info : 
  ('a, 'b, 'c, 'att, 'd, 'e, 'f, [< `WithSuffix | `WithoutSuffix ], 'g, 'h, 'i)
    t ->
  'att attached_info

val is_external : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  bool

val get_params_type : 
  ('a,
    'b,
    'd,
    'e,
    'f,
    'g,
    'h,
    [< `WithSuffix | `WithoutSuffix ] as 'i,
    'c,
    'j,
    'k)
    t ->
  ('a, 'i, 'c) Eliom_parameter.params_type

val post_params_type : 
  ('c, 'a, 'd, 'e, 'f, 'g, 'h, [< `WithSuffix | `WithoutSuffix ], 'i, 'b, 'j) t ->
  ('a, [ `WithoutSuffix ], 'b) Eliom_parameter.params_type

val sub_path : att -> Eliom_lib.Url.path

val full_path : att -> Eliom_lib.Url.path

val prefix : att -> string

val get_name : att -> Eliom_common.att_key_serv

val post_name : att -> Eliom_common.att_key_serv

val redirect_suffix : att -> bool

val na_name : non_att -> Eliom_common.na_key_serv

val na_keep_get_na_params : non_att -> bool

val max_use : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  int option

val timeout : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  float option

val https : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  bool

val priority : att -> int

val client_fun : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  ('a -> 'b -> result Lwt.t) Eliom_client_value.t option

val has_client_fun : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  bool

val keep_nl_params : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  [ `All | `None | `Persistent ]

val change_get_num : 
  ('a,
    'b,
    'meth,
    att,
    'co,
    'ext,
    'c,
    [< `WithSuffix | `WithoutSuffix ] as 'd,
    'e,
    'f,
    'return)
    t ->
  att ->
  Eliom_common.att_key_serv ->
  ('a, 'b, 'meth, att, 'co, 'ext, 'g, 'd, 'e, 'f, 'return) t

val register_delayed_get_or_na_coservice : 
  sp:Eliom_common.server_params ->
  (int * [< Eliom_common.user_scope ] * bool option) ->
  string

val register_delayed_post_coservice : 
  sp:Eliom_common.server_params ->
  (int * [< Eliom_common.user_scope ] * bool option) ->
  Eliom_common.att_key_serv ->
  string

type send_appl_content =

| XNever
| XAlways
| XSame_appl of string * string option

val send_appl_content : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  send_appl_content

val xhr_with_cookies : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  string option option

val internal_set_client_fun : 
  service:
    ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j)
      t ->
  ('a -> 'b -> result Lwt.t) Eliom_client_value.t ->
  unit

val set_client_fun : 
  ?app:string ->
  service:
    ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j)
      t ->
  ('a -> 'b -> result Lwt.t) ->
  unit

val reset_reload_fun : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  unit

val pre_applied_parameters : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  (string * Eliommod_parameters.param) list Eliom_lib.String.Table.t
  * (string * Eliommod_parameters.param) list

val reload_fun : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< `WithSuffix | `WithoutSuffix ], 'h, 'i, 'j) t ->
  ('a -> unit -> result Lwt.t) Eliom_client_value.t option

package eliom