🥮 mooncakes.io

har-toolkit

Validated HAR 1.2 parser and performance analysis toolkit for MoonBit

har
http-archive
performance
waterfall
redaction
moon add cpypypypy/har-toolkit@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
yesterday
Downloads
3
README

#cpypypypy/har-toolkit

Validated HAR 1.2 parser and offline performance analysis toolkit for MoonBit.

The package provides typed parsing, stable path diagnostics, resource limits, semantic validation, host/status/content statistics, filtering, privacy redaction, deterministic serialization, session comparison, bounded batch processing and evidence reports.

Version 0.1.0 accepts caller-provided strings. It does not capture traffic, automate browsers, replay requests or read files.

License: Apache-2.0.

#
HarBatchInput

source
pub struct HarBatchInput {
  label_value : String
  text_value : String
} derive(Eq, 
Debug)

#
HarBatchInput::label

source
fn HarBatchInput::label(self : HarBatchInput) -> String

#
HarBatchInput::new

source
fn HarBatchInput::new(label : String, text : String) -> Result[HarBatchInput, HarError]

#
HarBatchInput::text

source
fn HarBatchInput::text(self : HarBatchInput) -> String

#
HarBatchItem

source
pub struct HarBatchItem {
  label_value : String
  document_value : HarDocument?
  error_value : HarError?
} derive(Eq, 
Debug)

#
HarBatchItem::accepted

source
fn HarBatchItem::accepted(self : HarBatchItem) -> Bool

#
HarBatchItem::document

source
fn HarBatchItem::document(self : HarBatchItem) -> HarDocument?

#
HarBatchItem::error

source
fn HarBatchItem::error(self : HarBatchItem) -> HarError?

#
HarBatchItem::label

source
fn HarBatchItem::label(self : HarBatchItem) -> String

#
HarBatchResult

source
pub struct HarBatchResult {
  items_value : Array[HarBatchItem]
  accepted_value : Int
  rejected_value : Int
  total_entries_value : Int
  total_input_bytes_value : Int
} derive(Eq, 
Debug)

#
HarBatchResult::accepted

source
fn HarBatchResult::accepted(self : HarBatchResult) -> Int

#
HarBatchResult::find

source
fn HarBatchResult::find(self : HarBatchResult, label : String) -> HarBatchItem?

#
HarBatchResult::items

source

#
HarBatchResult::rejected

source
fn HarBatchResult::rejected(self : HarBatchResult) -> Int

#
HarBatchResult::total_entries

source
fn HarBatchResult::total_entries(self : HarBatchResult) -> Int

#
HarBatchResult::total_input_bytes

source
fn HarBatchResult::total_input_bytes(self : HarBatchResult) -> Int

#
HarBucket

source
pub struct HarBucket {
  label_value : String
  count_value : Int
  bytes_value : Double
  duration_value : Double
} derive(Eq, 
Debug)

#
HarBucket::average_duration

source
fn HarBucket::average_duration(self : HarBucket) -> Double

#
HarBucket::bytes

source
fn HarBucket::bytes(self : HarBucket) -> Double

#
HarBucket::count

source
fn HarBucket::count(self : HarBucket) -> Int

#
HarBucket::duration

source
fn HarBucket::duration(self : HarBucket) -> Double

#
HarBucket::label

source
fn HarBucket::label(self : HarBucket) -> String

#
HarBucketDelta

source
pub struct HarBucketDelta {
  label_value : String
  before_count_value : Int
  after_count_value : Int
  count_delta_value : Int
  before_bytes_value : Double
  after_bytes_value : Double
  bytes_delta_value : Double
  duration_delta_value : Double
} derive(Eq, 
Debug)

#
HarBucketDelta::after_bytes

source
fn HarBucketDelta::after_bytes(self : HarBucketDelta) -> Double

#
HarBucketDelta::after_count

source
fn HarBucketDelta::after_count(self : HarBucketDelta) -> Int

#
HarBucketDelta::before_bytes

source
fn HarBucketDelta::before_bytes(self : HarBucketDelta) -> Double

#
HarBucketDelta::before_count

source
fn HarBucketDelta::before_count(self : HarBucketDelta) -> Int

#
HarBucketDelta::bytes_delta

source
fn HarBucketDelta::bytes_delta(self : HarBucketDelta) -> Double

#
HarBucketDelta::count_delta

source
fn HarBucketDelta::count_delta(self : HarBucketDelta) -> Int

#
HarBucketDelta::duration_delta

source
fn HarBucketDelta::duration_delta(self : HarBucketDelta) -> Double

#
HarBucketDelta::label

source
fn HarBucketDelta::label(self : HarBucketDelta) -> String

#
HarCache

source
pub struct HarCache {
  before_request_value : HarCacheEntry?
  after_request_value : HarCacheEntry?
  comment_value : String?
} derive(Eq, 
Debug)

#
HarCache::after_request

source
fn HarCache::after_request(self : HarCache) -> HarCacheEntry?

#
HarCache::before_request

source
fn HarCache::before_request(self : HarCache) -> HarCacheEntry?

#
HarCache::comment

source
fn HarCache::comment(self : HarCache) -> String?

#
HarCache::new

source
fn HarCache::new(before_request? : HarCacheEntry, after_request? : HarCacheEntry, comment? : String) -> HarCache

#
HarCache::was_cached

source
fn HarCache::was_cached(self : HarCache) -> Bool

#
HarCache::was_updated

source
fn HarCache::was_updated(self : HarCache) -> Bool

#
HarCacheEntry

source
pub struct HarCacheEntry {
  expires_value : String?
  last_access_value : String
  etag_value : String
  hit_count_value : Double
  comment_value : String?
} derive(Eq, 
Debug)

#
HarCacheEntry::comment

source
fn HarCacheEntry::comment(self : HarCacheEntry) -> String?

#
HarCacheEntry::etag

source
fn HarCacheEntry::etag(self : HarCacheEntry) -> String

#
HarCacheEntry::expires

source
fn HarCacheEntry::expires(self : HarCacheEntry) -> String?

#
HarCacheEntry::hit_count

source
fn HarCacheEntry::hit_count(self : HarCacheEntry) -> Double

#
HarCacheEntry::last_access

source
fn HarCacheEntry::last_access(self : HarCacheEntry) -> String

#
HarCacheEntry::new

source
fn HarCacheEntry::new(last_access : String, etag : String, hit_count : Double, expires? : String, comment? : String) -> Result[HarCacheEntry, HarError]

#
HarComparison

source
pub struct HarComparison {
  metrics_value : Array[HarMetricDelta]
  hosts_value : Array[HarBucketDelta]
} derive(Eq, 
Debug)

#
HarComparison::find_host

source
fn HarComparison::find_host(self : HarComparison, host : String) -> HarBucketDelta?

#
HarComparison::find_metric

source
fn HarComparison::find_metric(self : HarComparison, name : String) -> HarMetricDelta?

#
HarComparison::hosts

source

#
HarComparison::metrics

source

#
HarContent

source
pub struct HarContent {
  size_value : Double
  compression_value : Double?
  mime_type_value : String
  text_value : String?
  encoding_value : String?
  comment_value : String?
} derive(Eq, 
Debug)

#
HarContent::comment

source
fn HarContent::comment(self : HarContent) -> String?

#
HarContent::compression

source
fn HarContent::compression(self : HarContent) -> Double?

#
HarContent::encoding

source
fn HarContent::encoding(self : HarContent) -> String?

#
HarContent::is_base64

source
fn HarContent::is_base64(self : HarContent) -> Bool

#
HarContent::known_size

source
fn HarContent::known_size(self : HarContent) -> Double?

#
HarContent::media_type

source
fn HarContent::media_type(self : HarContent) -> String

#
HarContent::mime_type

source
fn HarContent::mime_type(self : HarContent) -> String

#
HarContent::new

source
fn HarContent::new(size : Double, mime_type : String, compression? : Double, text? : String, encoding? : String, comment? : String) -> Result[HarContent, HarError]

#
HarContent::size

source
fn HarContent::size(self : HarContent) -> Double

#
HarContent::text

source
fn HarContent::text(self : HarContent) -> String?

#
HarContent::type_group

source
fn HarContent::type_group(self : HarContent) -> String

#
HarCookie

source
pub struct HarCookie {
  name_value : String
  value_value : String
  path_value : String?
  domain_value : String?
  expires_value : String?
  http_only_value : Bool?
  secure_value : Bool?
  comment_value : String?
} derive(Eq, 
Debug)

#
HarCookie::comment

source
fn HarCookie::comment(self : HarCookie) -> String?

#
HarCookie::domain

source
fn HarCookie::domain(self : HarCookie) -> String?

#
HarCookie::expires

source
fn HarCookie::expires(self : HarCookie) -> String?

#
HarCookie::http_only

source
fn HarCookie::http_only(self : HarCookie) -> Bool?

#
HarCookie::name

source
fn HarCookie::name(self : HarCookie) -> String

#
HarCookie::new

source
fn HarCookie::new(name : String, value : String, path? : String, domain? : String, expires? : String, http_only? : Bool, secure? : Bool, comment? : String) -> HarCookie

#
HarCookie::path

source
fn HarCookie::path(self : HarCookie) -> String?

#
HarCookie::secure

source
fn HarCookie::secure(self : HarCookie) -> Bool?

#
HarCookie::value

source
fn HarCookie::value(self : HarCookie) -> String

#
HarDocument

source
pub struct HarDocument {
  version_value : String
  creator_value : HarSoftware
  browser_value : HarSoftware?
  pages_value : Array[HarPage]
  entries_value : Array[HarEntry]
  comment_value : String?
} derive(Eq, 
Debug)

#
HarDocument::browser

source
fn HarDocument::browser(self : HarDocument) -> HarSoftware?

#
HarDocument::comment

source
fn HarDocument::comment(self : HarDocument) -> String?

#
HarDocument::creator

source
fn HarDocument::creator(self : HarDocument) -> HarSoftware

#
HarDocument::entries

source
fn HarDocument::entries(self : HarDocument) -> Array[HarEntry]

#
HarDocument::entries_for_page

source
fn HarDocument::entries_for_page(self : HarDocument, page_id : String) -> Array[HarEntry]

#
HarDocument::entry_count

source
fn HarDocument::entry_count(self : HarDocument) -> Int

#
HarDocument::error_entry_count

source
fn HarDocument::error_entry_count(self : HarDocument) -> Int

#
HarDocument::find_page

source
fn HarDocument::find_page(self : HarDocument, id : String) -> HarPage?

#
HarDocument::page_count

source
fn HarDocument::page_count(self : HarDocument) -> Int

#
HarDocument::pages

source
fn HarDocument::pages(self : HarDocument) -> Array[HarPage]

#
HarDocument::successful_entry_count

source
fn HarDocument::successful_entry_count(self : HarDocument) -> Int

#
HarDocument::unassigned_entries

source
fn HarDocument::unassigned_entries(self : HarDocument) -> Array[HarEntry]

#
HarDocument::version

source
fn HarDocument::version(self : HarDocument) -> String

#
HarEntry

source
pub struct HarEntry {
  page_ref_value : String?
  started_datetime_value : String
  time_value : Double
  request_value : HarRequest
  response_value : HarResponse
  cache_value : HarCache
  timings_value : HarTimings
  server_ip_value : String?
  connection_value : String?
  comment_value : String?
} derive(Eq, 
Debug)

#
HarEntry::cache

source
fn HarEntry::cache(self : HarEntry) -> HarCache

#
HarEntry::comment

source
fn HarEntry::comment(self : HarEntry) -> String?

#
HarEntry::connection

source
fn HarEntry::connection(self : HarEntry) -> String?

#
HarEntry::decoded_body_size

source
fn HarEntry::decoded_body_size(self : HarEntry) -> Double?

#
HarEntry::is_page_entry

source
fn HarEntry::is_page_entry(self : HarEntry, page_id : String) -> Bool

#
HarEntry::page_ref

source
fn HarEntry::page_ref(self : HarEntry) -> String?

#
HarEntry::request

source
fn HarEntry::request(self : HarEntry) -> HarRequest

#
HarEntry::response

source
fn HarEntry::response(self : HarEntry) -> HarResponse

#
HarEntry::server_ip_address

source
fn HarEntry::server_ip_address(self : HarEntry) -> String?

#
HarEntry::started_datetime

source
fn HarEntry::started_datetime(self : HarEntry) -> String

#
HarEntry::time

source
fn HarEntry::time(self : HarEntry) -> Double

#
HarEntry::timing_delta

source
fn HarEntry::timing_delta(self : HarEntry) -> Double

#
HarEntry::timings

source
fn HarEntry::timings(self : HarEntry) -> HarTimings

#
HarEntry::transferred_body_size

source
fn HarEntry::transferred_body_size(self : HarEntry) -> Double?

#
HarError

source
pub struct HarError {
  code_value : String
  path_value : String
  message_value : String
} derive(Eq, 
Debug)

#
HarError::at_field

source
fn HarError::at_field(self : HarError, field : String) -> HarError

#
HarError::code

source
fn HarError::code(self : HarError) -> String

#
HarError::format

source
fn HarError::format(self : HarError) -> String

#
HarError::message

source
fn HarError::message(self : HarError) -> String

#
HarError::new

source
fn HarError::new(code : HarErrorCode, path : String, message : String) -> HarError

#
HarError::path

source
fn HarError::path(self : HarError) -> String

#
HarErrorCode

source
pub(all) enum HarErrorCode {
  InvalidJson
  ExpectedObject
  ExpectedArray
  ExpectedString
  ExpectedNumber
  ExpectedBoolean
  MissingField
  InvalidField
  InvalidVersion
  InvalidUrl
  InvalidMethod
  InvalidStatus
  InvalidTiming
  InvalidSize
  InvalidDateTime
  InvalidEncoding
  LimitExceeded
  DuplicateIdentifier
  MissingPageReference
  ValidationFailure
} derive(Eq, 
Debug)

#
HarErrorCode::code

source
fn HarErrorCode::code(self : HarErrorCode) -> String

#
HarFilter

source
pub struct HarFilter {
  host_value : String?
  minimum_status_value : Double?
  maximum_status_value : Double?
  minimum_duration_value : Double?
  maximum_duration_value : Double?
  page_ref_value : String?
  secure_only_value : Bool
  methods_value : Array[String]
  content_types_value : Array[String]
} derive(Eq, 
Debug)

#
HarFilter::all

source
fn HarFilter::all() -> HarFilter

#
HarFilter::content_types

source
fn HarFilter::content_types(self : HarFilter) -> Array[String]

#
HarFilter::host

source
fn HarFilter::host(self : HarFilter) -> String?

#
HarFilter::matches

source
fn HarFilter::matches(self : HarFilter, entry : HarEntry) -> Bool

#
HarFilter::methods

source
fn HarFilter::methods(self : HarFilter) -> Array[String]

#
HarFilter::with_content_type

source
fn HarFilter::with_content_type(self : HarFilter, content_type : String) -> HarFilter

#
HarFilter::with_duration_range

source
fn HarFilter::with_duration_range(self : HarFilter, minimum : Double, maximum : Double) -> Result[HarFilter, HarError]

#
HarFilter::with_host

source
fn HarFilter::with_host(self : HarFilter, host : String) -> HarFilter

#
HarFilter::with_method

source
fn HarFilter::with_method(self : HarFilter, verb : String) -> HarFilter

#
HarFilter::with_page

source
fn HarFilter::with_page(self : HarFilter, page_ref : String) -> HarFilter

#
HarFilter::with_secure_only

source
fn HarFilter::with_secure_only(self : HarFilter) -> HarFilter

#
HarFilter::with_status_range

source
fn HarFilter::with_status_range(self : HarFilter, minimum : Double, maximum : Double) -> Result[HarFilter, HarError]

#
HarLimits

source
pub struct HarLimits {
  max_input_bytes_value : Int
  max_pages_value : Int
  max_entries_value : Int
  max_headers_per_message_value : Int
  max_cookies_per_message_value : Int
  max_query_parameters_value : Int
} derive(Eq, 
Debug)

#
HarLimits::max_cookies_per_message

source
fn HarLimits::max_cookies_per_message(self : HarLimits) -> Int

#
HarLimits::max_entries

source
fn HarLimits::max_entries(self : HarLimits) -> Int

#
HarLimits::max_headers_per_message

source
fn HarLimits::max_headers_per_message(self : HarLimits) -> Int

#
HarLimits::max_input_bytes

source
fn HarLimits::max_input_bytes(self : HarLimits) -> Int

#
HarLimits::max_pages

source
fn HarLimits::max_pages(self : HarLimits) -> Int

#
HarLimits::max_query_parameters

source
fn HarLimits::max_query_parameters(self : HarLimits) -> Int

#
HarLimits::new

source
fn HarLimits::new(max_input_bytes : Int, max_pages : Int, max_entries : Int, max_headers_per_message : Int, max_cookies_per_message : Int, max_query_parameters : Int) -> Result[HarLimits, HarError]

#
HarLimits::standard

source
fn HarLimits::standard() -> HarLimits

#
HarMetricDelta

source
pub struct HarMetricDelta {
  name_value : String
  before_value : Double
  after_value : Double
  delta_value : Double
} derive(Eq, 
Debug)

#
HarMetricDelta::after

source
fn HarMetricDelta::after(self : HarMetricDelta) -> Double

#
HarMetricDelta::before

source
fn HarMetricDelta::before(self : HarMetricDelta) -> Double

#
HarMetricDelta::decreased

source
fn HarMetricDelta::decreased(self : HarMetricDelta) -> Bool

#
HarMetricDelta::delta

source
fn HarMetricDelta::delta(self : HarMetricDelta) -> Double

#
HarMetricDelta::increased

source
fn HarMetricDelta::increased(self : HarMetricDelta) -> Bool

#
HarMetricDelta::name

source
fn HarMetricDelta::name(self : HarMetricDelta) -> String

#
HarMetricDelta::percent_change

source
fn HarMetricDelta::percent_change(self : HarMetricDelta) -> Double?

#
HarNameValue

source
pub struct HarNameValue {
  name_value : String
  value_value : String
  comment_value : String?
} derive(Eq, 
Debug)

#
HarNameValue::comment

source
fn HarNameValue::comment(self : HarNameValue) -> String?

#
HarNameValue::name

source
fn HarNameValue::name(self : HarNameValue) -> String

#
HarNameValue::name_equals

source
fn HarNameValue::name_equals(self : HarNameValue, expected : String) -> Bool

#
HarNameValue::new

source
fn HarNameValue::new(name : String, value : String, comment? : String) -> HarNameValue

#
HarNameValue::value

source
fn HarNameValue::value(self : HarNameValue) -> String

#
HarPage

source
pub struct HarPage {
  started_datetime_value : String
  id_value : String
  title_value : String
  page_timings_value : HarPageTimings
  comment_value : String?
} derive(Eq, 
Debug)

#
HarPage::comment

source
fn HarPage::comment(self : HarPage) -> String?

#
HarPage::id

source
fn HarPage::id(self : HarPage) -> String

#
HarPage::page_timings

source
fn HarPage::page_timings(self : HarPage) -> HarPageTimings

#
HarPage::started_datetime

source
fn HarPage::started_datetime(self : HarPage) -> String

#
HarPage::title

source
fn HarPage::title(self : HarPage) -> String

#
HarPageTimings

source
pub struct HarPageTimings {
  on_content_load_value : Double?
  on_load_value : Double?
  comment_value : String?
} derive(Eq, 
Debug)

#
HarPageTimings::comment

source
fn HarPageTimings::comment(self : HarPageTimings) -> String?

#
HarPageTimings::latest_event

source
fn HarPageTimings::latest_event(self : HarPageTimings) -> Double?

#
HarPageTimings::new

source
fn HarPageTimings::new(on_content_load? : Double, on_load? : Double, comment? : String) -> Result[HarPageTimings, HarError]

#
HarPageTimings::on_content_load

source
fn HarPageTimings::on_content_load(self : HarPageTimings) -> Double?

#
HarPageTimings::on_load

source
fn HarPageTimings::on_load(self : HarPageTimings) -> Double?

#
HarPostData

source
pub struct HarPostData {
  mime_type_value : String
  params_value : Array[HarPostParam]
  text_value : String?
  comment_value : String?
} derive(Eq, 
Debug)

#
HarPostData::comment

source
fn HarPostData::comment(self : HarPostData) -> String?

#
HarPostData::is_form_urlencoded

source
fn HarPostData::is_form_urlencoded(self : HarPostData) -> Bool

#
HarPostData::is_multipart

source
fn HarPostData::is_multipart(self : HarPostData) -> Bool

#
HarPostData::mime_type

source
fn HarPostData::mime_type(self : HarPostData) -> String

#
HarPostData::new

source
fn HarPostData::new(mime_type : String, params? : Array[HarPostParam], text? : String, comment? : String) -> HarPostData

#
HarPostData::params

source
fn HarPostData::params(self : HarPostData) -> Array[HarPostParam]

#
HarPostData::text

source
fn HarPostData::text(self : HarPostData) -> String?

#
HarPostParam

source
pub struct HarPostParam {
  name_value : String
  value_value : String?
  file_name_value : String?
  content_type_value : String?
  comment_value : String?
} derive(Eq, 
Debug)

#
HarPostParam::comment

source
fn HarPostParam::comment(self : HarPostParam) -> String?

#
HarPostParam::content_type

source
fn HarPostParam::content_type(self : HarPostParam) -> String?

#
HarPostParam::file_name

source
fn HarPostParam::file_name(self : HarPostParam) -> String?

#
HarPostParam::name

source
fn HarPostParam::name(self : HarPostParam) -> String

#
HarPostParam::new

source
fn HarPostParam::new(name : String, value? : String, file_name? : String, content_type? : String, comment? : String) -> HarPostParam

#
HarPostParam::value

source
fn HarPostParam::value(self : HarPostParam) -> String?

#
HarRedactionPolicy

source
pub struct HarRedactionPolicy {
  sensitive_headers_value : Array[String]
  sensitive_cookies_value : Array[String]
  sensitive_query_value : Array[String]
  replacement_value : String
  redact_post_text_value : Bool
  redact_response_text_value : Bool
} derive(Eq, 
Debug)

#
HarRedactionPolicy::keep_post_text

source

#
HarRedactionPolicy::redact_response_text

source
fn HarRedactionPolicy::redact_response_text(self : HarRedactionPolicy) -> HarRedactionPolicy

#
HarRedactionPolicy::standard

source

fn HarRedactionPolicy::with_cookie(self : HarRedactionPolicy, name : String) -> HarRedactionPolicy

#
HarRedactionPolicy::with_header

source
fn HarRedactionPolicy::with_header(self : HarRedactionPolicy, name : String) -> HarRedactionPolicy

#
HarRedactionPolicy::with_query

source
fn HarRedactionPolicy::with_query(self : HarRedactionPolicy, name : String) -> HarRedactionPolicy

#
HarRedactionPolicy::with_replacement

source
fn HarRedactionPolicy::with_replacement(self : HarRedactionPolicy, replacement : String) -> HarRedactionPolicy

#
HarRequest

source
pub struct HarRequest {
  method_value : String
  url_value : String
  http_version_value : String
  cookies_value : Array[HarCookie]
  headers_value : Array[HarNameValue]
  query_value : Array[HarNameValue]
  post_data_value : HarPostData?
  headers_size_value : Double
  body_size_value : Double
  comment_value : String?
} derive(Eq, 
Debug)

#
HarRequest::body_size

source
fn HarRequest::body_size(self : HarRequest) -> Double

#
HarRequest::comment

source
fn HarRequest::comment(self : HarRequest) -> String?

#
HarRequest::cookie_values

source
fn HarRequest::cookie_values(self : HarRequest, name : String) -> Array[String]

#
HarRequest::cookies

source
fn HarRequest::cookies(self : HarRequest) -> Array[HarCookie]

#
HarRequest::has_body

source
fn HarRequest::has_body(self : HarRequest) -> Bool

#
HarRequest::header_values

source
fn HarRequest::header_values(self : HarRequest, name : String) -> Array[String]

#
HarRequest::headers

source
fn HarRequest::headers(self : HarRequest) -> Array[HarNameValue]

#
HarRequest::headers_size

source
fn HarRequest::headers_size(self : HarRequest) -> Double

#
HarRequest::http_version

source
fn HarRequest::http_version(self : HarRequest) -> String

#
HarRequest::is_secure

source
fn HarRequest::is_secure(self : HarRequest) -> Bool

#
HarRequest::known_body_size

source
fn HarRequest::known_body_size(self : HarRequest) -> Double?

#
HarRequest::known_headers_size

source
fn HarRequest::known_headers_size(self : HarRequest) -> Double?

#
HarRequest::method_is

source
fn HarRequest::method_is(self : HarRequest, expected : String) -> Bool

#
HarRequest::post_data

source
fn HarRequest::post_data(self : HarRequest) -> HarPostData?

#
HarRequest::query

source
fn HarRequest::query(self : HarRequest) -> Array[HarNameValue]

#
HarRequest::query_values

source
fn HarRequest::query_values(self : HarRequest, name : String) -> Array[String]

#
HarRequest::request_method

source
fn HarRequest::request_method(self : HarRequest) -> String

#
HarRequest::url

source
fn HarRequest::url(self : HarRequest) -> String

#
HarResponse

source
pub struct HarResponse {
  status_value : Double
  status_text_value : String
  http_version_value : String
  cookies_value : Array[HarCookie]
  headers_value : Array[HarNameValue]
  content_value : HarContent
  redirect_url_value : String
  headers_size_value : Double
  body_size_value : Double
  comment_value : String?
} derive(Eq, 
Debug)

#
HarResponse::body_size

source
fn HarResponse::body_size(self : HarResponse) -> Double

#
HarResponse::comment

source
fn HarResponse::comment(self : HarResponse) -> String?

#
HarResponse::content

source
fn HarResponse::content(self : HarResponse) -> HarContent

#
HarResponse::cookies

source
fn HarResponse::cookies(self : HarResponse) -> Array[HarCookie]

#
HarResponse::header_values

source
fn HarResponse::header_values(self : HarResponse, name : String) -> Array[String]

#
HarResponse::headers

source
fn HarResponse::headers(self : HarResponse) -> Array[HarNameValue]

#
HarResponse::headers_size

source
fn HarResponse::headers_size(self : HarResponse) -> Double

#
HarResponse::http_version

source
fn HarResponse::http_version(self : HarResponse) -> String

#
HarResponse::is_error

source
fn HarResponse::is_error(self : HarResponse) -> Bool

#
HarResponse::is_redirect

source
fn HarResponse::is_redirect(self : HarResponse) -> Bool

#
HarResponse::is_success

source
fn HarResponse::is_success(self : HarResponse) -> Bool

#
HarResponse::known_body_size

source
fn HarResponse::known_body_size(self : HarResponse) -> Double?

#
HarResponse::known_headers_size

source
fn HarResponse::known_headers_size(self : HarResponse) -> Double?

#
HarResponse::redirect_url

source
fn HarResponse::redirect_url(self : HarResponse) -> String

#
HarResponse::status

source
fn HarResponse::status(self : HarResponse) -> Double

#
HarResponse::status_class

source
fn HarResponse::status_class(self : HarResponse) -> String

#
HarResponse::status_text

source
fn HarResponse::status_text(self : HarResponse) -> String

#
HarSoftware

source
pub struct HarSoftware {
  name_value : String
  version_value : String
  comment_value : String?
} derive(Eq, 
Debug)

#
HarSoftware::comment

source
fn HarSoftware::comment(self : HarSoftware) -> String?

#
HarSoftware::name

source
fn HarSoftware::name(self : HarSoftware) -> String

#
HarSoftware::new

source
fn HarSoftware::new(name : String, version : String, comment? : String) -> Result[HarSoftware, HarError]

#
HarSoftware::version

source
fn HarSoftware::version(self : HarSoftware) -> String

#
HarStatistics

source
pub struct HarStatistics {
  entry_count_value : Int
  page_count_value : Int
  successful_count_value : Int
  redirect_count_value : Int
  error_count_value : Int
  secure_count_value : Int
  cached_count_value : Int
  unknown_body_size_count_value : Int
  request_bytes_value : Double
  response_bytes_value : Double
  decoded_bytes_value : Double
  duration_value : Double
  hosts_value : Array[HarBucket]
  status_classes_value : Array[HarBucket]
  content_types_value : Array[HarBucket]
} derive(Eq, 
Debug)

#
HarStatistics::average_duration

source
fn HarStatistics::average_duration(self : HarStatistics) -> Double

#
HarStatistics::cache_ratio

source
fn HarStatistics::cache_ratio(self : HarStatistics) -> Double

#
HarStatistics::cached_count

source
fn HarStatistics::cached_count(self : HarStatistics) -> Int

#
HarStatistics::content_types

source
fn HarStatistics::content_types(self : HarStatistics) -> Array[HarBucket]

#
HarStatistics::decoded_bytes

source
fn HarStatistics::decoded_bytes(self : HarStatistics) -> Double

#
HarStatistics::duration

source
fn HarStatistics::duration(self : HarStatistics) -> Double

#
HarStatistics::entry_count

source
fn HarStatistics::entry_count(self : HarStatistics) -> Int

#
HarStatistics::error_count

source
fn HarStatistics::error_count(self : HarStatistics) -> Int

#
HarStatistics::find_content_type

source
fn HarStatistics::find_content_type(self : HarStatistics, content_type : String) -> HarBucket?

#
HarStatistics::find_host

source
fn HarStatistics::find_host(self : HarStatistics, host : String) -> HarBucket?

#
HarStatistics::find_status_class

source
fn HarStatistics::find_status_class(self : HarStatistics, status_class : String) -> HarBucket?

#
HarStatistics::hosts

source

#
HarStatistics::page_count

source
fn HarStatistics::page_count(self : HarStatistics) -> Int

#
HarStatistics::redirect_count

source
fn HarStatistics::redirect_count(self : HarStatistics) -> Int

#
HarStatistics::request_bytes

source
fn HarStatistics::request_bytes(self : HarStatistics) -> Double

#
HarStatistics::response_bytes

source
fn HarStatistics::response_bytes(self : HarStatistics) -> Double

#
HarStatistics::secure_count

source
fn HarStatistics::secure_count(self : HarStatistics) -> Int

#
HarStatistics::secure_ratio

source
fn HarStatistics::secure_ratio(self : HarStatistics) -> Double

#
HarStatistics::status_classes

source
fn HarStatistics::status_classes(self : HarStatistics) -> Array[HarBucket]

#
HarStatistics::successful_count

source
fn HarStatistics::successful_count(self : HarStatistics) -> Int

#
HarStatistics::unknown_body_size_count

source
fn HarStatistics::unknown_body_size_count(self : HarStatistics) -> Int

#
HarTimings

source
pub struct HarTimings {
  blocked_value : Double?
  dns_value : Double?
  connect_value : Double?
  send_value : Double
  wait_value : Double
  receive_value : Double
  ssl_value : Double?
  comment_value : String?
} derive(Eq, 
Debug)

#
HarTimings::blocked

source
fn HarTimings::blocked(self : HarTimings) -> Double?

#
HarTimings::comment

source
fn HarTimings::comment(self : HarTimings) -> String?

#
HarTimings::connect

source
fn HarTimings::connect(self : HarTimings) -> Double?

#
HarTimings::dns

source
fn HarTimings::dns(self : HarTimings) -> Double?

#
HarTimings::dominant_phase

source
fn HarTimings::dominant_phase(self : HarTimings) -> String

#
HarTimings::has_ssl

source
fn HarTimings::has_ssl(self : HarTimings) -> Bool

#
HarTimings::known_total

source
fn HarTimings::known_total(self : HarTimings) -> Double

#
HarTimings::network_total

source
fn HarTimings::network_total(self : HarTimings) -> Double

#
HarTimings::new

source
fn HarTimings::new(blocked? : Double, dns? : Double, connect? : Double, send : Double, wait : Double, receive : Double, ssl? : Double, comment? : String) -> Result[HarTimings, HarError]

#
HarTimings::receive

source
fn HarTimings::receive(self : HarTimings) -> Double

#
HarTimings::send

source
fn HarTimings::send(self : HarTimings) -> Double

#
HarTimings::ssl

source
fn HarTimings::ssl(self : HarTimings) -> Double?

#
HarTimings::transport_total

source
fn HarTimings::transport_total(self : HarTimings) -> Double

#
HarTimings::wait

source
fn HarTimings::wait(self : HarTimings) -> Double

#
HarValidationPolicy

source
pub struct HarValidationPolicy {
  timing_tolerance_value : Double
  require_absolute_urls_value : Bool
  require_page_references_value : Bool
} derive(Eq, 
Debug)

#
HarValidationPolicy::new

source
fn HarValidationPolicy::new(timing_tolerance : Double, require_absolute_urls : Bool, require_page_references : Bool) -> Result[HarValidationPolicy, HarError]

#
HarValidationPolicy::require_absolute_urls

source
fn HarValidationPolicy::require_absolute_urls(self : HarValidationPolicy) -> Bool

#
HarValidationPolicy::require_page_references

source
fn HarValidationPolicy::require_page_references(self : HarValidationPolicy) -> Bool

#
HarValidationPolicy::standard

source

#
HarValidationPolicy::timing_tolerance

source
fn HarValidationPolicy::timing_tolerance(self : HarValidationPolicy) -> Double

#
HarWaterfallItem

source
pub struct HarWaterfallItem {
  index_value : Int
  page_ref_value : String?
  url_value : String
  status_value : Double
  duration_value : Double
  dominant_phase_value : String
  transferred_bytes_value : Double?
} derive(Eq, 
Debug)

#
HarWaterfallItem::dominant_phase

source
fn HarWaterfallItem::dominant_phase(self : HarWaterfallItem) -> String

#
HarWaterfallItem::duration

source
fn HarWaterfallItem::duration(self : HarWaterfallItem) -> Double

#
HarWaterfallItem::index

source
fn HarWaterfallItem::index(self : HarWaterfallItem) -> Int

#
HarWaterfallItem::page_ref

source
fn HarWaterfallItem::page_ref(self : HarWaterfallItem) -> String?

#
HarWaterfallItem::status

source
fn HarWaterfallItem::status(self : HarWaterfallItem) -> Double

#
HarWaterfallItem::transferred_bytes

source
fn HarWaterfallItem::transferred_bytes(self : HarWaterfallItem) -> Double?

#
HarWaterfallItem::url

source
fn HarWaterfallItem::url(self : HarWaterfallItem) -> String

#
ValidationIssue

source
pub struct ValidationIssue {
  severity_value : String
  code_value : String
  path_value : String
  message_value : String
} derive(Eq, 
Debug)

#
ValidationIssue::code

source
fn ValidationIssue::code(self : ValidationIssue) -> String

#
ValidationIssue::error

source
fn ValidationIssue::error(code : String, path : String, message : String) -> ValidationIssue

#
ValidationIssue::format

source
fn ValidationIssue::format(self : ValidationIssue) -> String

#
ValidationIssue::message

source
fn ValidationIssue::message(self : ValidationIssue) -> String

#
ValidationIssue::path

source
fn ValidationIssue::path(self : ValidationIssue) -> String

#
ValidationIssue::severity

source
fn ValidationIssue::severity(self : ValidationIssue) -> String

#
ValidationIssue::warning

source
fn ValidationIssue::warning(code : String, path : String, message : String) -> ValidationIssue

#
ValidationResult

source
pub struct ValidationResult {
  issues_value : Array[ValidationIssue]
} derive(Eq, 
Debug)

#
ValidationResult::error_count

source
fn ValidationResult::error_count(self : ValidationResult) -> Int

#
ValidationResult::is_valid

source
fn ValidationResult::is_valid(self : ValidationResult) -> Bool

#
ValidationResult::issue_count

source
fn ValidationResult::issue_count(self : ValidationResult) -> Int

#
ValidationResult::issues

source

#
ValidationResult::new

source

#
ValidationResult::warning_count

source
fn ValidationResult::warning_count(self : ValidationResult) -> Int

#
analyze_har

source
fn analyze_har(document : HarDocument) -> HarStatistics

#
append_json_field

source
fn append_json_field(path : String, field : String) -> String

#
append_json_index

source
fn append_json_index(path : String, index : Int) -> String

#
build_waterfall

source
fn build_waterfall(document : HarDocument) -> Array[HarWaterfallItem]

#
compare_har

source
fn compare_har(before : HarDocument, after : HarDocument) -> HarComparison

#
parse_cache

source
fn parse_cache(input : String) -> Result[HarCache, HarError]

#
parse_content

source
fn parse_content(input : String) -> Result[HarContent, HarError]

#
parse_cookies

source
fn parse_cookies(input : String) -> Result[Array[HarCookie], HarError]

#
parse_entry

source
fn parse_entry(input : String) -> Result[HarEntry, HarError]

#
parse_har

source
fn parse_har(input : String) -> Result[HarDocument, HarError]

#
parse_har_batch

source
fn parse_har_batch(inputs : Array[HarBatchInput], max_items : Int, max_total_input_bytes : Int, limits? : HarLimits) -> Result[HarBatchResult, HarError]

#
parse_har_with_limits

source
fn parse_har_with_limits(input : String, limits : HarLimits) -> Result[HarDocument, HarError]

#
parse_name_values

source
fn parse_name_values(input : String) -> Result[Array[HarNameValue], HarError]

#
parse_page

source
fn parse_page(input : String) -> Result[HarPage, HarError]

#
parse_post_data

source
fn parse_post_data(input : String) -> Result[HarPostData, HarError]

#
parse_request

source
fn parse_request(input : String) -> Result[HarRequest, HarError]

#
parse_response

source
fn parse_response(input : String) -> Result[HarResponse, HarError]

#
parse_software

source
fn parse_software(input : String) -> Result[HarSoftware, HarError]

#
parse_timings

source
fn parse_timings(input : String) -> Result[HarTimings, HarError]

#
redact_har

source
fn redact_har(document : HarDocument, policy? : HarRedactionPolicy) -> HarDocument

#
render_comparison_json

source
fn render_comparison_json(comparison : HarComparison) -> String

#
render_comparison_text

source
fn render_comparison_text(comparison : HarComparison) -> String

#
render_statistics_json

source
fn render_statistics_json(statistics : HarStatistics) -> String

#
render_statistics_text

source
fn render_statistics_text(statistics : HarStatistics) -> String

#
render_validation_json

source
fn render_validation_json(result : ValidationResult) -> String

#
render_validation_text

source
fn render_validation_text(result : ValidationResult) -> String

#
render_waterfall_json

source
fn render_waterfall_json(items : Array[HarWaterfallItem]) -> String

#
select_entries

source
fn select_entries(document : HarDocument, filter : HarFilter) -> Array[HarEntry]

#
serialize_har

source
fn serialize_har(document : HarDocument, indent? : Int) -> Result[String, HarError]

#
url_host

source
fn url_host(url : String) -> String

#
url_scheme

source
fn url_scheme(url : String) -> String

#
validate_har

source
fn validate_har(document : HarDocument, policy? : HarValidationPolicy) -> ValidationResult

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io