Time (logger.Logger.Time)

include module type of Core_kernel.Time

module type S_kernel_without_zone = Core_kernel__.Time0_intf.S

module type S_kernel = Core_kernel__.Time_intf.S

type underlying = Core_kernel__.Time_float0.underlying

type t = Core_kernel__.Time_float0.t

val bin_size_t : t Bin_prot.Size.sizer

val bin_write_t : t Bin_prot.Write.writer

val bin_read_t : t Bin_prot.Read.reader

val __bin_read_t__ : ( int -> t ) Bin_prot.Read.reader

val bin_shape_t : Bin_prot.Shape.t

val bin_writer_t : t Bin_prot.Type_class.writer

val bin_reader_t : t Bin_prot.Type_class.reader

val bin_t : t Bin_prot.Type_class.t

val hash_fold_t : 
  Ppx_hash_lib.Std.Hash.state ->
  t ->
  Ppx_hash_lib.Std.Hash.state

val hash : t -> Ppx_hash_lib.Std.Hash.hash_value

val typerep_of_t : t Typerep_lib.Std_internal.Typerep.t

val typename_of_t : t Typerep_lib.Typename.t

module Span : sig ... end

module Ofday : sig ... end

module Replace_polymorphic_compare : sig ... end

val (>=.) : t -> t -> bool

val (<=.) : t -> t -> bool

val (=.) : t -> t -> bool

val (>.) : t -> t -> bool

val (<.) : t -> t -> bool

val (<>.) : t -> t -> bool

val robustly_compare : t -> t -> int

val next : t -> t

val prev : t -> t

val to_span_since_epoch : t -> Span.t

val of_span_since_epoch : Span.t -> t

val (>=) : t -> t -> bool

val (<=) : t -> t -> bool

val (=) : t -> t -> bool

val (>) : t -> t -> bool

val (<) : t -> t -> bool

val (<>) : t -> t -> bool

val equal : t -> t -> bool

val compare : t -> t -> int

val min : t -> t -> t

val max : t -> t -> t

val ascending : t -> t -> int

val descending : t -> t -> int

val between : t -> low:t -> high:t -> bool

val clamp_exn : t -> min:t -> max:t -> t

val clamp : t -> min:t -> max:t -> t Base__.Or_error.t

type comparator_witness = Core_kernel__.Time_float0.comparator_witness

val comparator : ( t, comparator_witness ) Base__Comparator.comparator

val validate_lbound : min:t Base__.Maybe_bound.t -> t Base__.Validate.check

val validate_ubound : max:t Base__.Maybe_bound.t -> t Base__.Validate.check

val validate_bound : 
  min:t Base__.Maybe_bound.t ->
  max:t Base__.Maybe_bound.t ->
  t Base__.Validate.check

module Date_and_ofday : sig ... end

val next_multiple : 
  ?can_equal_after:Core_kernel__.Import.bool ->
  base:t ->
  after:t ->
  interval:Span.t ->
  Core_kernel__.Import.unit ->
  t

val prev_multiple : 
  ?can_equal_before:Core_kernel__.Import.bool ->
  base:t ->
  before:t ->
  interval:Span.t ->
  Core_kernel__.Import.unit ->
  t

val now : Core_kernel__.Import.unit -> t

module Zone : sig ... end

val add : t -> Span.t -> t

val sub : t -> Span.t -> t

val diff : t -> t -> Span.t

val abs_diff : t -> t -> Span.t

val quickcheck_generator : t Base_quickcheck.Generator.t

val quickcheck_observer : t Base_quickcheck.Observer.t

val quickcheck_shrinker : t Base_quickcheck.Shrinker.t

val gen_incl : t -> t -> t Base_quickcheck.Generator.t

val gen_uniform_incl : t -> t -> t Base_quickcheck.Generator.t

val is_earlier : t -> than:t -> Core_kernel__.Import.bool

val is_later : t -> than:t -> Core_kernel__.Import.bool

val of_date_ofday : 
  zone:Core_kernel__.Zone.t ->
  Core_kernel__Time_intf.Date.t ->
  Ofday.t ->
  t

val of_date_ofday_precise : 
  Core_kernel__Time_intf.Date.t ->
  Ofday.t ->
  zone:Core_kernel__.Zone.t ->
  [ `Never of t | `Once of t | `Twice of t * t ]

val to_date_ofday : 
  t ->
  zone:Core_kernel__.Zone.t ->
  Core_kernel__Time_intf.Date.t * Ofday.t

val to_date_ofday_precise : 
  t ->
  zone:Core_kernel__.Zone.t ->
  Core_kernel__Time_intf.Date.t
  * Ofday.t
  * [ `Also_at of t
    | `Also_skipped of Core_kernel__Time_intf.Date.t * Ofday.t
    | `Only ]

val to_date : t -> zone:Core_kernel__.Zone.t -> Core_kernel__Time_intf.Date.t

val to_ofday : t -> zone:Core_kernel__.Zone.t -> Ofday.t

val reset_date_cache : Core_kernel__.Import.unit -> Core_kernel__.Import.unit

val epoch : t

val convert : 
  from_tz:Core_kernel__.Zone.t ->
  to_tz:Core_kernel__.Zone.t ->
  Core_kernel__Time_intf.Date.t ->
  Ofday.t ->
  Core_kernel__Time_intf.Date.t * Ofday.t

val utc_offset : t -> zone:Core_kernel__.Zone.t -> Span.t

val of_string : string -> t

val to_string : t -> string

val to_filename_string : 
  t ->
  zone:Core_kernel__.Zone.t ->
  Core_kernel__.Import.string

val of_filename_string : 
  Core_kernel__.Import.string ->
  zone:Core_kernel__.Zone.t ->
  t

val to_string_abs : 
  t ->
  zone:Core_kernel__.Zone.t ->
  Core_kernel__.Import.string

val to_string_abs_trimmed : 
  t ->
  zone:Core_kernel__.Zone.t ->
  Core_kernel__.Import.string

val to_string_abs_parts : 
  t ->
  zone:Core_kernel__.Zone.t ->
  Core_kernel__.Import.string Core_kernel__.Import.list

val to_string_trimmed : 
  t ->
  zone:Core_kernel__.Zone.t ->
  Core_kernel__.Import.string

val to_sec_string : 
  t ->
  zone:Core_kernel__.Zone.t ->
  Core_kernel__.Import.string

val of_localized_string : 
  zone:Core_kernel__.Zone.t ->
  Core_kernel__.Import.string ->
  t

val of_string_gen : 
  default_zone:( Core_kernel__.Import.unit -> Core_kernel__.Zone.t ) ->
  find_zone:( Core_kernel__.Import.string -> Core_kernel__.Zone.t ) ->
  Core_kernel__.Import.string ->
  t

val to_string_iso8601_basic : 
  t ->
  zone:Core_kernel__.Zone.t ->
  Core_kernel__.Import.string

val occurrence : 
  [ `First_after_or_at | `Last_before_or_at ] ->
  t ->
  ofday:Ofday.t ->
  zone:Core_kernel__.Zone.t ->
  t

module Stable : sig ... end

val to_yojson : t -> Yojson.Safe.t

val of_yojson : Yojson.Safe.t -> ( t, string ) Core_kernel.Result.t

val pretty_to_string : t -> string

val set_pretty_to_string : ( t -> string ) -> unit