Network

nw_browser_state_cancelled

const nw_browser_state_cancelled: nw_browser_state_t

var nw_browser_state_cancelled: nw_browser_state_t { get }

nw_browser_state_failed

const nw_browser_state_failed: nw_browser_state_t

var nw_browser_state_failed: nw_browser_state_t { get }

nw_browser_state_invalid

const nw_browser_state_invalid: nw_browser_state_t

var nw_browser_state_invalid: nw_browser_state_t { get }

nw_browser_state_ready

const nw_browser_state_ready: nw_browser_state_t

var nw_browser_state_ready: nw_browser_state_t { get }

nw_browser_state_waiting

const nw_browser_state_waiting: nw_browser_state_t

var nw_browser_state_waiting: nw_browser_state_t { get }

nw_connection_group_state_cancelled

const nw_connection_group_state_cancelled: nw_connection_group_state_t

var nw_connection_group_state_cancelled: nw_connection_group_state_t { get }

nw_connection_group_state_failed

const nw_connection_group_state_failed: nw_connection_group_state_t

var nw_connection_group_state_failed: nw_connection_group_state_t { get }

nw_connection_group_state_invalid

const nw_connection_group_state_invalid: nw_connection_group_state_t

var nw_connection_group_state_invalid: nw_connection_group_state_t { get }

nw_connection_group_state_ready

const nw_connection_group_state_ready: nw_connection_group_state_t

var nw_connection_group_state_ready: nw_connection_group_state_t { get }

nw_connection_group_state_waiting

const nw_connection_group_state_waiting: nw_connection_group_state_t

var nw_connection_group_state_waiting: nw_connection_group_state_t { get }

nw_connection_state_cancelled

const nw_connection_state_cancelled: nw_connection_state_t

var nw_connection_state_cancelled: nw_connection_state_t { get }

nw_connection_state_failed

const nw_connection_state_failed: nw_connection_state_t

var nw_connection_state_failed: nw_connection_state_t { get }

nw_connection_state_invalid

const nw_connection_state_invalid: nw_connection_state_t

var nw_connection_state_invalid: nw_connection_state_t { get }

nw_connection_state_preparing

const nw_connection_state_preparing: nw_connection_state_t

var nw_connection_state_preparing: nw_connection_state_t { get }

nw_connection_state_ready

const nw_connection_state_ready: nw_connection_state_t

var nw_connection_state_ready: nw_connection_state_t { get }

nw_connection_state_waiting

const nw_connection_state_waiting: nw_connection_state_t

var nw_connection_state_waiting: nw_connection_state_t { get }

nw_data_transfer_report_state_collected

const nw_data_transfer_report_state_collected: nw_data_transfer_report_state_t

var nw_data_transfer_report_state_collected: nw_data_transfer_report_state_t { get }

nw_data_transfer_report_state_collecting

const nw_data_transfer_report_state_collecting: nw_data_transfer_report_state_t

var nw_data_transfer_report_state_collecting: nw_data_transfer_report_state_t { get }

nw_endpoint_type_address

const nw_endpoint_type_address: nw_endpoint_type_t

var nw_endpoint_type_address: nw_endpoint_type_t { get }

nw_endpoint_type_bonjour_service

const nw_endpoint_type_bonjour_service: nw_endpoint_type_t

var nw_endpoint_type_bonjour_service: nw_endpoint_type_t { get }

nw_endpoint_type_host

const nw_endpoint_type_host: nw_endpoint_type_t

var nw_endpoint_type_host: nw_endpoint_type_t { get }

nw_endpoint_type_invalid

const nw_endpoint_type_invalid: nw_endpoint_type_t

var nw_endpoint_type_invalid: nw_endpoint_type_t { get }

nw_endpoint_type_url

const nw_endpoint_type_url: nw_endpoint_type_t

var nw_endpoint_type_url: nw_endpoint_type_t { get }

nw_error_domain_dns

const nw_error_domain_dns: nw_error_domain_t

var nw_error_domain_dns: nw_error_domain_t { get }

nw_error_domain_invalid

const nw_error_domain_invalid: nw_error_domain_t

var nw_error_domain_invalid: nw_error_domain_t { get }

nw_error_domain_posix

const nw_error_domain_posix: nw_error_domain_t

var nw_error_domain_posix: nw_error_domain_t { get }

nw_error_domain_tls

const nw_error_domain_tls: nw_error_domain_t

var nw_error_domain_tls: nw_error_domain_t { get }

nw_error_domain_wifi_aware

const nw_error_domain_wifi_aware: nw_error_domain_t

var nw_error_domain_wifi_aware: nw_error_domain_t { get }

nw_ethernet_channel_state_cancelled

const nw_ethernet_channel_state_cancelled: SDKHandle

var nw_ethernet_channel_state_cancelled: nw_ethernet_channel_state_t { get }

nw_ethernet_channel_state_failed

const nw_ethernet_channel_state_failed: SDKHandle

var nw_ethernet_channel_state_failed: nw_ethernet_channel_state_t { get }

nw_ethernet_channel_state_invalid

const nw_ethernet_channel_state_invalid: SDKHandle

var nw_ethernet_channel_state_invalid: nw_ethernet_channel_state_t { get }

nw_ethernet_channel_state_preparing

const nw_ethernet_channel_state_preparing: SDKHandle

var nw_ethernet_channel_state_preparing: nw_ethernet_channel_state_t { get }

nw_ethernet_channel_state_ready

const nw_ethernet_channel_state_ready: SDKHandle

var nw_ethernet_channel_state_ready: nw_ethernet_channel_state_t { get }

nw_ethernet_channel_state_waiting

const nw_ethernet_channel_state_waiting: SDKHandle

var nw_ethernet_channel_state_waiting: nw_ethernet_channel_state_t { get }

nw_framer_start_result_ready

const nw_framer_start_result_ready: nw_framer_start_result_t

var nw_framer_start_result_ready: nw_framer_start_result_t { get }

nw_framer_start_result_will_mark_ready

const nw_framer_start_result_will_mark_ready: nw_framer_start_result_t

var nw_framer_start_result_will_mark_ready: nw_framer_start_result_t { get }

nw_interface_radio_type_cell_cdma

const nw_interface_radio_type_cell_cdma: nw_interface_radio_type_t

var nw_interface_radio_type_cell_cdma: nw_interface_radio_type_t { get }

nw_interface_radio_type_cell_endc_mmw

const nw_interface_radio_type_cell_endc_mmw: nw_interface_radio_type_t

var nw_interface_radio_type_cell_endc_mmw: nw_interface_radio_type_t { get }

nw_interface_radio_type_cell_endc_sub6

const nw_interface_radio_type_cell_endc_sub6: nw_interface_radio_type_t

var nw_interface_radio_type_cell_endc_sub6: nw_interface_radio_type_t { get }

nw_interface_radio_type_cell_evdo

const nw_interface_radio_type_cell_evdo: nw_interface_radio_type_t

var nw_interface_radio_type_cell_evdo: nw_interface_radio_type_t { get }

nw_interface_radio_type_cell_gsm

const nw_interface_radio_type_cell_gsm: nw_interface_radio_type_t

var nw_interface_radio_type_cell_gsm: nw_interface_radio_type_t { get }

nw_interface_radio_type_cell_lte

const nw_interface_radio_type_cell_lte: nw_interface_radio_type_t

var nw_interface_radio_type_cell_lte: nw_interface_radio_type_t { get }

nw_interface_radio_type_cell_nr_sa_mmw

const nw_interface_radio_type_cell_nr_sa_mmw: nw_interface_radio_type_t

var nw_interface_radio_type_cell_nr_sa_mmw: nw_interface_radio_type_t { get }

nw_interface_radio_type_cell_nr_sa_sub6

const nw_interface_radio_type_cell_nr_sa_sub6: nw_interface_radio_type_t

var nw_interface_radio_type_cell_nr_sa_sub6: nw_interface_radio_type_t { get }

nw_interface_radio_type_cell_wcdma

const nw_interface_radio_type_cell_wcdma: nw_interface_radio_type_t

var nw_interface_radio_type_cell_wcdma: nw_interface_radio_type_t { get }

nw_interface_radio_type_unknown

const nw_interface_radio_type_unknown: nw_interface_radio_type_t

var nw_interface_radio_type_unknown: nw_interface_radio_type_t { get }

nw_interface_radio_type_wifi_a

const nw_interface_radio_type_wifi_a: nw_interface_radio_type_t

var nw_interface_radio_type_wifi_a: nw_interface_radio_type_t { get }

nw_interface_radio_type_wifi_ac

const nw_interface_radio_type_wifi_ac: nw_interface_radio_type_t

var nw_interface_radio_type_wifi_ac: nw_interface_radio_type_t { get }

nw_interface_radio_type_wifi_ax

const nw_interface_radio_type_wifi_ax: nw_interface_radio_type_t

var nw_interface_radio_type_wifi_ax: nw_interface_radio_type_t { get }

nw_interface_radio_type_wifi_b

const nw_interface_radio_type_wifi_b: nw_interface_radio_type_t

var nw_interface_radio_type_wifi_b: nw_interface_radio_type_t { get }

nw_interface_radio_type_wifi_g

const nw_interface_radio_type_wifi_g: nw_interface_radio_type_t

var nw_interface_radio_type_wifi_g: nw_interface_radio_type_t { get }

nw_interface_radio_type_wifi_n

const nw_interface_radio_type_wifi_n: nw_interface_radio_type_t

var nw_interface_radio_type_wifi_n: nw_interface_radio_type_t { get }

nw_interface_type_cellular

const nw_interface_type_cellular: nw_interface_type_t

var nw_interface_type_cellular: nw_interface_type_t { get }

nw_interface_type_loopback

const nw_interface_type_loopback: nw_interface_type_t

var nw_interface_type_loopback: nw_interface_type_t { get }

nw_interface_type_other

const nw_interface_type_other: nw_interface_type_t

var nw_interface_type_other: nw_interface_type_t { get }

nw_interface_type_wifi

const nw_interface_type_wifi: nw_interface_type_t

var nw_interface_type_wifi: nw_interface_type_t { get }

nw_interface_type_wired

const nw_interface_type_wired: nw_interface_type_t

var nw_interface_type_wired: nw_interface_type_t { get }

nw_ip_ecn_flag_ce

const nw_ip_ecn_flag_ce: nw_ip_ecn_flag_t

var nw_ip_ecn_flag_ce: nw_ip_ecn_flag_t { get }

nw_ip_ecn_flag_ect_0

const nw_ip_ecn_flag_ect_0: nw_ip_ecn_flag_t

var nw_ip_ecn_flag_ect_0: nw_ip_ecn_flag_t { get }

nw_ip_ecn_flag_ect_1

const nw_ip_ecn_flag_ect_1: nw_ip_ecn_flag_t

var nw_ip_ecn_flag_ect_1: nw_ip_ecn_flag_t { get }

nw_ip_ecn_flag_non_ect

const nw_ip_ecn_flag_non_ect: nw_ip_ecn_flag_t

var nw_ip_ecn_flag_non_ect: nw_ip_ecn_flag_t { get }

nw_ip_local_address_preference_default

const nw_ip_local_address_preference_default: nw_ip_local_address_preference_t

var nw_ip_local_address_preference_default: nw_ip_local_address_preference_t { get }

nw_ip_local_address_preference_stable

const nw_ip_local_address_preference_stable: nw_ip_local_address_preference_t

var nw_ip_local_address_preference_stable: nw_ip_local_address_preference_t { get }

nw_ip_local_address_preference_temporary

const nw_ip_local_address_preference_temporary: nw_ip_local_address_preference_t

var nw_ip_local_address_preference_temporary: nw_ip_local_address_preference_t { get }

nw_ip_version_4

const nw_ip_version_4: nw_ip_version_t

var nw_ip_version_4: nw_ip_version_t { get }

nw_ip_version_6

const nw_ip_version_6: nw_ip_version_t

var nw_ip_version_6: nw_ip_version_t { get }

nw_ip_version_any

const nw_ip_version_any: nw_ip_version_t

var nw_ip_version_any: nw_ip_version_t { get }

nw_link_quality_good

const nw_link_quality_good: nw_link_quality_t

var nw_link_quality_good: nw_link_quality_t { get }

nw_link_quality_minimal

const nw_link_quality_minimal: nw_link_quality_t

var nw_link_quality_minimal: nw_link_quality_t { get }

nw_link_quality_moderate

const nw_link_quality_moderate: nw_link_quality_t

var nw_link_quality_moderate: nw_link_quality_t { get }

nw_link_quality_unknown

const nw_link_quality_unknown: nw_link_quality_t

var nw_link_quality_unknown: nw_link_quality_t { get }

nw_listener_state_cancelled

const nw_listener_state_cancelled: nw_listener_state_t

var nw_listener_state_cancelled: nw_listener_state_t { get }

nw_listener_state_failed

const nw_listener_state_failed: nw_listener_state_t

var nw_listener_state_failed: nw_listener_state_t { get }

nw_listener_state_invalid

const nw_listener_state_invalid: nw_listener_state_t

var nw_listener_state_invalid: nw_listener_state_t { get }

nw_listener_state_ready

const nw_listener_state_ready: nw_listener_state_t

var nw_listener_state_ready: nw_listener_state_t { get }

nw_listener_state_waiting

const nw_listener_state_waiting: nw_listener_state_t

var nw_listener_state_waiting: nw_listener_state_t { get }

nw_multipath_service_aggregate

const nw_multipath_service_aggregate: nw_multipath_service_t

var nw_multipath_service_aggregate: nw_multipath_service_t { get }

nw_multipath_service_disabled

const nw_multipath_service_disabled: nw_multipath_service_t

var nw_multipath_service_disabled: nw_multipath_service_t { get }

nw_multipath_service_handover

const nw_multipath_service_handover: nw_multipath_service_t

var nw_multipath_service_handover: nw_multipath_service_t { get }

nw_multipath_service_interactive

const nw_multipath_service_interactive: nw_multipath_service_t

var nw_multipath_service_interactive: nw_multipath_service_t { get }

nw_multipath_version_0

const nw_multipath_version_0: nw_multipath_version_t

var nw_multipath_version_0: nw_multipath_version_t { get }

nw_multipath_version_1

const nw_multipath_version_1: nw_multipath_version_t

var nw_multipath_version_1: nw_multipath_version_t { get }

nw_multipath_version_unspecified

const nw_multipath_version_unspecified: nw_multipath_version_t

var nw_multipath_version_unspecified: nw_multipath_version_t { get }

nw_parameters_expired_dns_behavior_allow

const nw_parameters_expired_dns_behavior_allow: nw_parameters_expired_dns_behavior_t

var nw_parameters_expired_dns_behavior_allow: nw_parameters_expired_dns_behavior_t { get }

nw_parameters_expired_dns_behavior_default

const nw_parameters_expired_dns_behavior_default: nw_parameters_expired_dns_behavior_t

var nw_parameters_expired_dns_behavior_default: nw_parameters_expired_dns_behavior_t { get }

nw_parameters_expired_dns_behavior_persistent

const nw_parameters_expired_dns_behavior_persistent: nw_parameters_expired_dns_behavior_t

var nw_parameters_expired_dns_behavior_persistent: nw_parameters_expired_dns_behavior_t { get }

nw_parameters_expired_dns_behavior_prohibit

const nw_parameters_expired_dns_behavior_prohibit: nw_parameters_expired_dns_behavior_t

var nw_parameters_expired_dns_behavior_prohibit: nw_parameters_expired_dns_behavior_t { get }

nw_path_status_invalid

const nw_path_status_invalid: nw_path_status_t

var nw_path_status_invalid: nw_path_status_t { get }

nw_path_status_satisfiable

const nw_path_status_satisfiable: nw_path_status_t

var nw_path_status_satisfiable: nw_path_status_t { get }

nw_path_status_satisfied

const nw_path_status_satisfied: nw_path_status_t

var nw_path_status_satisfied: nw_path_status_t { get }

nw_path_status_unsatisfied

const nw_path_status_unsatisfied: nw_path_status_t

var nw_path_status_unsatisfied: nw_path_status_t { get }

nw_path_unsatisfied_reason_cellular_denied

const nw_path_unsatisfied_reason_cellular_denied: nw_path_unsatisfied_reason_t

var nw_path_unsatisfied_reason_cellular_denied: nw_path_unsatisfied_reason_t { get }

nw_path_unsatisfied_reason_local_network_denied

const nw_path_unsatisfied_reason_local_network_denied: nw_path_unsatisfied_reason_t

var nw_path_unsatisfied_reason_local_network_denied: nw_path_unsatisfied_reason_t { get }

nw_path_unsatisfied_reason_not_available

const nw_path_unsatisfied_reason_not_available: nw_path_unsatisfied_reason_t

var nw_path_unsatisfied_reason_not_available: nw_path_unsatisfied_reason_t { get }

nw_path_unsatisfied_reason_vpn_inactive

const nw_path_unsatisfied_reason_vpn_inactive: nw_path_unsatisfied_reason_t

var nw_path_unsatisfied_reason_vpn_inactive: nw_path_unsatisfied_reason_t { get }

nw_path_unsatisfied_reason_wifi_denied

const nw_path_unsatisfied_reason_wifi_denied: nw_path_unsatisfied_reason_t

var nw_path_unsatisfied_reason_wifi_denied: nw_path_unsatisfied_reason_t { get }

nw_quic_stream_type_bidirectional

const nw_quic_stream_type_bidirectional: nw_quic_stream_type_t

var nw_quic_stream_type_bidirectional: nw_quic_stream_type_t { get }

nw_quic_stream_type_datagram

const nw_quic_stream_type_datagram: nw_quic_stream_type_t

var nw_quic_stream_type_datagram: nw_quic_stream_type_t { get }

nw_quic_stream_type_unidirectional

const nw_quic_stream_type_unidirectional: nw_quic_stream_type_t

var nw_quic_stream_type_unidirectional: nw_quic_stream_type_t { get }

nw_quic_stream_type_unknown

const nw_quic_stream_type_unknown: nw_quic_stream_type_t

var nw_quic_stream_type_unknown: nw_quic_stream_type_t { get }

nw_report_resolution_protocol_https

const nw_report_resolution_protocol_https: nw_report_resolution_protocol_t

var nw_report_resolution_protocol_https: nw_report_resolution_protocol_t { get }

nw_report_resolution_protocol_tcp

const nw_report_resolution_protocol_tcp: nw_report_resolution_protocol_t

var nw_report_resolution_protocol_tcp: nw_report_resolution_protocol_t { get }

nw_report_resolution_protocol_tls

const nw_report_resolution_protocol_tls: nw_report_resolution_protocol_t

var nw_report_resolution_protocol_tls: nw_report_resolution_protocol_t { get }

nw_report_resolution_protocol_udp

const nw_report_resolution_protocol_udp: nw_report_resolution_protocol_t

var nw_report_resolution_protocol_udp: nw_report_resolution_protocol_t { get }

nw_report_resolution_protocol_unknown

const nw_report_resolution_protocol_unknown: nw_report_resolution_protocol_t

var nw_report_resolution_protocol_unknown: nw_report_resolution_protocol_t { get }

nw_report_resolution_source_cache

const nw_report_resolution_source_cache: nw_report_resolution_source_t

var nw_report_resolution_source_cache: nw_report_resolution_source_t { get }

nw_report_resolution_source_expired_cache

const nw_report_resolution_source_expired_cache: nw_report_resolution_source_t

var nw_report_resolution_source_expired_cache: nw_report_resolution_source_t { get }

nw_report_resolution_source_query

const nw_report_resolution_source_query: nw_report_resolution_source_t

var nw_report_resolution_source_query: nw_report_resolution_source_t { get }

nw_service_class_background

const nw_service_class_background: nw_service_class_t

var nw_service_class_background: nw_service_class_t { get }

nw_service_class_best_effort

const nw_service_class_best_effort: nw_service_class_t

var nw_service_class_best_effort: nw_service_class_t { get }

nw_service_class_interactive_video

const nw_service_class_interactive_video: nw_service_class_t

var nw_service_class_interactive_video: nw_service_class_t { get }

nw_service_class_interactive_voice

const nw_service_class_interactive_voice: nw_service_class_t

var nw_service_class_interactive_voice: nw_service_class_t { get }

nw_service_class_responsive_data

const nw_service_class_responsive_data: nw_service_class_t

var nw_service_class_responsive_data: nw_service_class_t { get }

nw_service_class_signaling

const nw_service_class_signaling: nw_service_class_t

var nw_service_class_signaling: nw_service_class_t { get }

nw_txt_record_find_key_empty_value

const nw_txt_record_find_key_empty_value: nw_txt_record_find_key_t

var nw_txt_record_find_key_empty_value: nw_txt_record_find_key_t { get }

nw_txt_record_find_key_invalid

const nw_txt_record_find_key_invalid: nw_txt_record_find_key_t

var nw_txt_record_find_key_invalid: nw_txt_record_find_key_t { get }

nw_txt_record_find_key_no_value

const nw_txt_record_find_key_no_value: nw_txt_record_find_key_t

var nw_txt_record_find_key_no_value: nw_txt_record_find_key_t { get }

nw_txt_record_find_key_non_empty_value

const nw_txt_record_find_key_non_empty_value: nw_txt_record_find_key_t

var nw_txt_record_find_key_non_empty_value: nw_txt_record_find_key_t { get }

nw_txt_record_find_key_not_present

const nw_txt_record_find_key_not_present: nw_txt_record_find_key_t

var nw_txt_record_find_key_not_present: nw_txt_record_find_key_t { get }

nw_ws_close_code_abnormal_closure

const nw_ws_close_code_abnormal_closure: nw_ws_close_code_t

var nw_ws_close_code_abnormal_closure: nw_ws_close_code_t { get }

nw_ws_close_code_going_away

const nw_ws_close_code_going_away: nw_ws_close_code_t

var nw_ws_close_code_going_away: nw_ws_close_code_t { get }

nw_ws_close_code_internal_server_error

const nw_ws_close_code_internal_server_error: nw_ws_close_code_t

var nw_ws_close_code_internal_server_error: nw_ws_close_code_t { get }

nw_ws_close_code_invalid_frame_payload_data

const nw_ws_close_code_invalid_frame_payload_data: nw_ws_close_code_t

var nw_ws_close_code_invalid_frame_payload_data: nw_ws_close_code_t { get }

nw_ws_close_code_mandatory_extension

const nw_ws_close_code_mandatory_extension: nw_ws_close_code_t

var nw_ws_close_code_mandatory_extension: nw_ws_close_code_t { get }

nw_ws_close_code_message_too_big

const nw_ws_close_code_message_too_big: nw_ws_close_code_t

var nw_ws_close_code_message_too_big: nw_ws_close_code_t { get }

nw_ws_close_code_no_status_received

const nw_ws_close_code_no_status_received: nw_ws_close_code_t

var nw_ws_close_code_no_status_received: nw_ws_close_code_t { get }

nw_ws_close_code_normal_closure

const nw_ws_close_code_normal_closure: nw_ws_close_code_t

var nw_ws_close_code_normal_closure: nw_ws_close_code_t { get }

nw_ws_close_code_policy_violation

const nw_ws_close_code_policy_violation: nw_ws_close_code_t

var nw_ws_close_code_policy_violation: nw_ws_close_code_t { get }

nw_ws_close_code_protocol_error

const nw_ws_close_code_protocol_error: nw_ws_close_code_t

var nw_ws_close_code_protocol_error: nw_ws_close_code_t { get }

nw_ws_close_code_tls_handshake

const nw_ws_close_code_tls_handshake: nw_ws_close_code_t

var nw_ws_close_code_tls_handshake: nw_ws_close_code_t { get }

nw_ws_close_code_unsupported_data

const nw_ws_close_code_unsupported_data: nw_ws_close_code_t

var nw_ws_close_code_unsupported_data: nw_ws_close_code_t { get }

nw_ws_opcode_binary

const nw_ws_opcode_binary: nw_ws_opcode_t

var nw_ws_opcode_binary: nw_ws_opcode_t { get }

nw_ws_opcode_close

const nw_ws_opcode_close: nw_ws_opcode_t

var nw_ws_opcode_close: nw_ws_opcode_t { get }

nw_ws_opcode_cont

const nw_ws_opcode_cont: nw_ws_opcode_t

var nw_ws_opcode_cont: nw_ws_opcode_t { get }

nw_ws_opcode_invalid

const nw_ws_opcode_invalid: nw_ws_opcode_t

var nw_ws_opcode_invalid: nw_ws_opcode_t { get }

nw_ws_opcode_ping

const nw_ws_opcode_ping: nw_ws_opcode_t

var nw_ws_opcode_ping: nw_ws_opcode_t { get }

nw_ws_opcode_pong

const nw_ws_opcode_pong: nw_ws_opcode_t

var nw_ws_opcode_pong: nw_ws_opcode_t { get }

nw_ws_opcode_text

const nw_ws_opcode_text: nw_ws_opcode_t

var nw_ws_opcode_text: nw_ws_opcode_t { get }

nw_ws_response_status_accept

const nw_ws_response_status_accept: nw_ws_response_status_t

var nw_ws_response_status_accept: nw_ws_response_status_t { get }

nw_ws_response_status_invalid

const nw_ws_response_status_invalid: nw_ws_response_status_t

var nw_ws_response_status_invalid: nw_ws_response_status_t { get }

nw_ws_response_status_reject

const nw_ws_response_status_reject: nw_ws_response_status_t

var nw_ws_response_status_reject: nw_ws_response_status_t { get }

nw_ws_version_13

const nw_ws_version_13: nw_ws_version_t

var nw_ws_version_13: nw_ws_version_t { get }

nw_ws_version_invalid

const nw_ws_version_invalid: nw_ws_version_t

var nw_ws_version_invalid: nw_ws_version_t { get }

nw_browse_result_change_identical

const nw_browse_result_change_identical: number

var nw_browse_result_change_identical: Int { get }

nw_browse_result_change_interface_added

const nw_browse_result_change_interface_added: number

var nw_browse_result_change_interface_added: Int { get }

nw_browse_result_change_interface_removed

const nw_browse_result_change_interface_removed: number

var nw_browse_result_change_interface_removed: Int { get }

nw_browse_result_change_invalid

const nw_browse_result_change_invalid: number

var nw_browse_result_change_invalid: Int { get }

nw_browse_result_change_result_added

const nw_browse_result_change_result_added: number

var nw_browse_result_change_result_added: Int { get }

nw_browse_result_change_result_removed

const nw_browse_result_change_result_removed: number

var nw_browse_result_change_result_removed: Int { get }

nw_browse_result_change_txt_record_changed

const nw_browse_result_change_txt_record_changed: number

var nw_browse_result_change_txt_record_changed: Int { get }

nw_advertise_descriptor_copy_txt_record_object

nw_advertise_descriptor_copy_txt_record_object(advertise_descriptor: Implements<OS_nw_advertise_descriptor> | SDKHandle): (SDKHandle) | null

func nw_advertise_descriptor_copy_txt_record_object(_ advertise_descriptor: nw_advertise_descriptor_t) -> nw_txt_record_t?

nw_advertise_descriptor_create_application_service

nw_advertise_descriptor_create_application_service(application_service_name: SDKHandle): SDKHandle

func nw_advertise_descriptor_create_application_service(_ application_service_name: UnsafePointer<CChar>) -> nw_advertise_descriptor_t

nw_advertise_descriptor_create_bonjour_service

nw_advertise_descriptor_create_bonjour_service(name: (SDKHandle) | null, type: SDKHandle, domain?: (SDKHandle) | null): (SDKHandle) | null

func nw_advertise_descriptor_create_bonjour_service(_ name: UnsafePointer<CChar>?, _ type: UnsafePointer<CChar>, _ domain: UnsafePointer<CChar>?) -> nw_advertise_descriptor_t?

nw_advertise_descriptor_get_application_service_name

nw_advertise_descriptor_get_application_service_name(advertise_descriptor: Implements<OS_nw_advertise_descriptor> | SDKHandle): (SDKHandle) | null

func nw_advertise_descriptor_get_application_service_name(_ advertise_descriptor: nw_advertise_descriptor_t) -> UnsafePointer<CChar>?

nw_advertise_descriptor_get_no_auto_rename

nw_advertise_descriptor_get_no_auto_rename(advertise_descriptor: Implements<OS_nw_advertise_descriptor> | SDKHandle): boolean

func nw_advertise_descriptor_get_no_auto_rename(_ advertise_descriptor: nw_advertise_descriptor_t) -> Bool

nw_advertise_descriptor_set_no_auto_rename

nw_advertise_descriptor_set_no_auto_rename(advertise_descriptor: Implements<OS_nw_advertise_descriptor> | SDKHandle, no_auto_rename: boolean): void

func nw_advertise_descriptor_set_no_auto_rename(_ advertise_descriptor: nw_advertise_descriptor_t, _ no_auto_rename: Bool)

nw_advertise_descriptor_set_txt_record

nw_advertise_descriptor_set_txt_record(advertise_descriptor: Implements<OS_nw_advertise_descriptor> | SDKHandle, txt_record: (SDKHandle) | null, txt_length: number): void

func nw_advertise_descriptor_set_txt_record(_ advertise_descriptor: nw_advertise_descriptor_t, _ txt_record: UnsafeRawPointer?, _ txt_length: Int)

nw_advertise_descriptor_set_txt_record_object

nw_advertise_descriptor_set_txt_record_object(advertise_descriptor: Implements<OS_nw_advertise_descriptor> | SDKHandle, txt_record?: (Implements<OS_nw_txt_record> | SDKHandle) | null): void

func nw_advertise_descriptor_set_txt_record_object(_ advertise_descriptor: nw_advertise_descriptor_t, _ txt_record: nw_txt_record_t?)

nw_browse_descriptor_create_application_service

nw_browse_descriptor_create_application_service(application_service_name: SDKHandle): SDKHandle

func nw_browse_descriptor_create_application_service(_ application_service_name: UnsafePointer<CChar>) -> nw_browse_descriptor_t

nw_browse_descriptor_create_bonjour_service

nw_browse_descriptor_create_bonjour_service(type: SDKHandle, domain?: (SDKHandle) | null): SDKHandle

func nw_browse_descriptor_create_bonjour_service(_ type: UnsafePointer<CChar>, _ domain: UnsafePointer<CChar>?) -> nw_browse_descriptor_t

nw_browse_descriptor_get_application_service_name

nw_browse_descriptor_get_application_service_name(descriptor: Implements<OS_nw_browse_descriptor> | SDKHandle): (SDKHandle) | null

func nw_browse_descriptor_get_application_service_name(_ descriptor: nw_browse_descriptor_t) -> UnsafePointer<CChar>?

nw_browse_descriptor_get_bonjour_service_domain

nw_browse_descriptor_get_bonjour_service_domain(descriptor: Implements<OS_nw_browse_descriptor> | SDKHandle): (SDKHandle) | null

func nw_browse_descriptor_get_bonjour_service_domain(_ descriptor: nw_browse_descriptor_t) -> UnsafePointer<CChar>?

nw_browse_descriptor_get_bonjour_service_type

nw_browse_descriptor_get_bonjour_service_type(descriptor: Implements<OS_nw_browse_descriptor> | SDKHandle): SDKHandle

func nw_browse_descriptor_get_bonjour_service_type(_ descriptor: nw_browse_descriptor_t) -> UnsafePointer<CChar>

nw_browse_descriptor_get_include_txt_record

nw_browse_descriptor_get_include_txt_record(descriptor: Implements<OS_nw_browse_descriptor> | SDKHandle): boolean

func nw_browse_descriptor_get_include_txt_record(_ descriptor: nw_browse_descriptor_t) -> Bool

nw_browse_descriptor_set_include_txt_record

nw_browse_descriptor_set_include_txt_record(descriptor: Implements<OS_nw_browse_descriptor> | SDKHandle, include_txt_record: boolean): void

func nw_browse_descriptor_set_include_txt_record(_ descriptor: nw_browse_descriptor_t, _ include_txt_record: Bool)

nw_browse_result_copy_endpoint

nw_browse_result_copy_endpoint(result: Implements<OS_nw_browse_result> | SDKHandle): SDKHandle

func nw_browse_result_copy_endpoint(_ result: nw_browse_result_t) -> nw_endpoint_t

nw_browse_result_copy_txt_record_object

nw_browse_result_copy_txt_record_object(result: Implements<OS_nw_browse_result> | SDKHandle): (SDKHandle) | null

func nw_browse_result_copy_txt_record_object(_ result: nw_browse_result_t) -> nw_txt_record_t?

nw_browse_result_get_changes

nw_browse_result_get_changes(old_result?: (Implements<OS_nw_browse_result> | SDKHandle) | null, new_result?: (Implements<OS_nw_browse_result> | SDKHandle) | null): number

func nw_browse_result_get_changes(_ old_result: nw_browse_result_t?, _ new_result: nw_browse_result_t?) -> nw_browse_result_change_t

nw_browse_result_get_interfaces_count

nw_browse_result_get_interfaces_count(result: Implements<OS_nw_browse_result> | SDKHandle): number

func nw_browse_result_get_interfaces_count(_ result: nw_browse_result_t) -> Int

nw_browser_cancel

nw_browser_cancel(browser: Implements<OS_nw_browser> | SDKHandle): void

func nw_browser_cancel(_ browser: nw_browser_t)

nw_browser_copy_browse_descriptor

nw_browser_copy_browse_descriptor(browser: Implements<OS_nw_browser> | SDKHandle): SDKHandle

func nw_browser_copy_browse_descriptor(_ browser: nw_browser_t) -> nw_browse_descriptor_t

nw_browser_copy_parameters

nw_browser_copy_parameters(browser: Implements<OS_nw_browser> | SDKHandle): SDKHandle

func nw_browser_copy_parameters(_ browser: nw_browser_t) -> nw_parameters_t

nw_browser_create

nw_browser_create(descriptor: Implements<OS_nw_browse_descriptor> | SDKHandle, parameters?: (Implements<OS_nw_parameters> | SDKHandle) | null): SDKHandle

func nw_browser_create(_ descriptor: nw_browse_descriptor_t, _ parameters: nw_parameters_t?) -> nw_browser_t

nw_browser_set_browse_results_changed_handler

nw_browser_set_browse_results_changed_handler(browser: Implements<OS_nw_browser> | SDKHandle, handler?: (((arg0: SDKHandle, arg1: SDKHandle, arg2: boolean) => void)) | null): void

func nw_browser_set_browse_results_changed_handler(_ browser: nw_browser_t, _ handler: nw_browser_browse_results_changed_handler_t?)

nw_browser_set_queue

nw_browser_set_queue(browser: Implements<OS_nw_browser> | SDKHandle, queue: _Dispatch_DispatchQueue): void

func nw_browser_set_queue(_ browser: nw_browser_t, _ queue: dispatch_queue_t)

nw_browser_set_state_changed_handler

nw_browser_set_state_changed_handler(browser: Implements<OS_nw_browser> | SDKHandle, state_changed_handler?: (((arg0: nw_browser_state_t, arg1: (SDKHandle) | null) => void)) | null): void

func nw_browser_set_state_changed_handler(_ browser: nw_browser_t, _ state_changed_handler: nw_browser_state_changed_handler_t?)

nw_browser_start

nw_browser_start(browser: Implements<OS_nw_browser> | SDKHandle): void

func nw_browser_start(_ browser: nw_browser_t)

nw_connection_access_establishment_report

nw_connection_access_establishment_report(connection: Implements<OS_nw_connection> | SDKHandle, queue: _Dispatch_DispatchQueue, access_block: ((arg0: (SDKHandle) | null) => void)): void

func nw_connection_access_establishment_report(_ connection: nw_connection_t, _ queue: dispatch_queue_t, _ access_block: @escaping nw_establishment_report_access_block_t)

nw_connection_batch

nw_connection_batch(connection: Implements<OS_nw_connection> | SDKHandle, batch_block: (() => void)): void

func nw_connection_batch(_ connection: nw_connection_t, _ batch_block: () -> Void)

nw_connection_cancel

nw_connection_cancel(connection: Implements<OS_nw_connection> | SDKHandle): void

func nw_connection_cancel(_ connection: nw_connection_t)

nw_connection_cancel_current_endpoint

nw_connection_cancel_current_endpoint(connection: Implements<OS_nw_connection> | SDKHandle): void

func nw_connection_cancel_current_endpoint(_ connection: nw_connection_t)

nw_connection_copy_current_path

nw_connection_copy_current_path(connection: Implements<OS_nw_connection> | SDKHandle): (SDKHandle) | null

func nw_connection_copy_current_path(_ connection: nw_connection_t) -> nw_path_t?

nw_connection_copy_description

nw_connection_copy_description(connection: Implements<OS_nw_connection> | SDKHandle): SDKHandle

func nw_connection_copy_description(_ connection: nw_connection_t) -> UnsafeMutablePointer<CChar>

nw_connection_copy_endpoint

nw_connection_copy_endpoint(connection: Implements<OS_nw_connection> | SDKHandle): SDKHandle

func nw_connection_copy_endpoint(_ connection: nw_connection_t) -> nw_endpoint_t

nw_connection_copy_parameters

nw_connection_copy_parameters(connection: Implements<OS_nw_connection> | SDKHandle): SDKHandle

func nw_connection_copy_parameters(_ connection: nw_connection_t) -> nw_parameters_t

nw_connection_copy_protocol_metadata

nw_connection_copy_protocol_metadata(connection: Implements<OS_nw_connection> | SDKHandle, definition: Implements<OS_nw_protocol_definition> | SDKHandle): (SDKHandle) | null

func nw_connection_copy_protocol_metadata(_ connection: nw_connection_t, _ definition: nw_protocol_definition_t) -> nw_protocol_metadata_t?

nw_connection_create

nw_connection_create(endpoint: Implements<OS_nw_endpoint> | SDKHandle, parameters: Implements<OS_nw_parameters> | SDKHandle): SDKHandle

func nw_connection_create(_ endpoint: nw_endpoint_t, _ parameters: nw_parameters_t) -> nw_connection_t

nw_connection_create_new_data_transfer_report

nw_connection_create_new_data_transfer_report(connection: Implements<OS_nw_connection> | SDKHandle): SDKHandle

func nw_connection_create_new_data_transfer_report(_ connection: nw_connection_t) -> nw_data_transfer_report_t

nw_connection_force_cancel

nw_connection_force_cancel(connection: Implements<OS_nw_connection> | SDKHandle): void

func nw_connection_force_cancel(_ connection: nw_connection_t)

nw_connection_get_maximum_datagram_size

nw_connection_get_maximum_datagram_size(connection: Implements<OS_nw_connection> | SDKHandle): number

func nw_connection_get_maximum_datagram_size(_ connection: nw_connection_t) -> UInt32

nw_connection_group_cancel

nw_connection_group_cancel(group: Implements<OS_nw_connection_group> | SDKHandle): void

func nw_connection_group_cancel(_ group: nw_connection_group_t)

nw_connection_group_copy_descriptor

nw_connection_group_copy_descriptor(group: Implements<OS_nw_connection_group> | SDKHandle): SDKHandle

func nw_connection_group_copy_descriptor(_ group: nw_connection_group_t) -> nw_group_descriptor_t

nw_connection_group_copy_local_endpoint_for_message

nw_connection_group_copy_local_endpoint_for_message(group: Implements<OS_nw_connection_group> | SDKHandle, context: Implements<OS_nw_content_context> | SDKHandle): (SDKHandle) | null

func nw_connection_group_copy_local_endpoint_for_message(_ group: nw_connection_group_t, _ context: nw_content_context_t) -> nw_endpoint_t?

nw_connection_group_copy_parameters

nw_connection_group_copy_parameters(group: Implements<OS_nw_connection_group> | SDKHandle): SDKHandle

func nw_connection_group_copy_parameters(_ group: nw_connection_group_t) -> nw_parameters_t

nw_connection_group_copy_path_for_message

nw_connection_group_copy_path_for_message(group: Implements<OS_nw_connection_group> | SDKHandle, context: Implements<OS_nw_content_context> | SDKHandle): (SDKHandle) | null

func nw_connection_group_copy_path_for_message(_ group: nw_connection_group_t, _ context: nw_content_context_t) -> nw_path_t?

nw_connection_group_copy_protocol_metadata

nw_connection_group_copy_protocol_metadata(group: Implements<OS_nw_connection_group> | SDKHandle, definition: Implements<OS_nw_protocol_definition> | SDKHandle): (SDKHandle) | null

func nw_connection_group_copy_protocol_metadata(_ group: nw_connection_group_t, _ definition: nw_protocol_definition_t) -> nw_protocol_metadata_t?

nw_connection_group_copy_protocol_metadata_for_message

nw_connection_group_copy_protocol_metadata_for_message(group: Implements<OS_nw_connection_group> | SDKHandle, context: Implements<OS_nw_content_context> | SDKHandle, definition: Implements<OS_nw_protocol_definition> | SDKHandle): (SDKHandle) | null

func nw_connection_group_copy_protocol_metadata_for_message(_ group: nw_connection_group_t, _ context: nw_content_context_t, _ definition: nw_protocol_definition_t) -> nw_protocol_metadata_t?

nw_connection_group_copy_remote_endpoint_for_message

nw_connection_group_copy_remote_endpoint_for_message(group: Implements<OS_nw_connection_group> | SDKHandle, context: Implements<OS_nw_content_context> | SDKHandle): (SDKHandle) | null

func nw_connection_group_copy_remote_endpoint_for_message(_ group: nw_connection_group_t, _ context: nw_content_context_t) -> nw_endpoint_t?

nw_connection_group_create

nw_connection_group_create(group_descriptor: Implements<OS_nw_group_descriptor> | SDKHandle, parameters: Implements<OS_nw_parameters> | SDKHandle): SDKHandle

func nw_connection_group_create(_ group_descriptor: nw_group_descriptor_t, _ parameters: nw_parameters_t) -> nw_connection_group_t

nw_connection_group_extract_connection

nw_connection_group_extract_connection(group: Implements<OS_nw_connection_group> | SDKHandle, endpoint?: (Implements<OS_nw_endpoint> | SDKHandle) | null, protocol_options?: (Implements<OS_nw_protocol_options> | SDKHandle) | null): (SDKHandle) | null

func nw_connection_group_extract_connection(_ group: nw_connection_group_t, _ endpoint: nw_endpoint_t?, _ protocol_options: nw_protocol_options_t?) -> nw_connection_t?

nw_connection_group_extract_connection_for_message

nw_connection_group_extract_connection_for_message(group: Implements<OS_nw_connection_group> | SDKHandle, context: Implements<OS_nw_content_context> | SDKHandle): (SDKHandle) | null

func nw_connection_group_extract_connection_for_message(_ group: nw_connection_group_t, _ context: nw_content_context_t) -> nw_connection_t?

nw_connection_group_reinsert_extracted_connection

nw_connection_group_reinsert_extracted_connection(group: Implements<OS_nw_connection_group> | SDKHandle, connection: Implements<OS_nw_connection> | SDKHandle): boolean

func nw_connection_group_reinsert_extracted_connection(_ group: nw_connection_group_t, _ connection: nw_connection_t) -> Bool

nw_connection_group_reply

nw_connection_group_reply(group: Implements<OS_nw_connection_group> | SDKHandle, inbound_message: Implements<OS_nw_content_context> | SDKHandle, outbound_message: Implements<OS_nw_content_context> | SDKHandle, content?: (SDKHandle) | null): void

func nw_connection_group_reply(_ group: nw_connection_group_t, _ inbound_message: nw_content_context_t, _ outbound_message: nw_content_context_t, _ content: dispatch_data_t?)

nw_connection_group_send_message

nw_connection_group_send_message(group: Implements<OS_nw_connection_group> | SDKHandle, content: (SDKHandle) | null, endpoint: (Implements<OS_nw_endpoint> | SDKHandle) | null, context: Implements<OS_nw_content_context> | SDKHandle, completion: ((arg0: (SDKHandle) | null) => void)): void

func nw_connection_group_send_message(_ group: nw_connection_group_t, _ content: dispatch_data_t?, _ endpoint: nw_endpoint_t?, _ context: nw_content_context_t, _ completion: @escaping nw_connection_group_send_completion_t)

nw_connection_group_set_new_connection_handler

nw_connection_group_set_new_connection_handler(group: Implements<OS_nw_connection_group> | SDKHandle, new_connection_handler?: (((arg0: SDKHandle) => void)) | null): void

func nw_connection_group_set_new_connection_handler(_ group: nw_connection_group_t, _ new_connection_handler: nw_connection_group_new_connection_handler_t?)

nw_connection_group_set_queue

nw_connection_group_set_queue(group: Implements<OS_nw_connection_group> | SDKHandle, queue: _Dispatch_DispatchQueue): void

func nw_connection_group_set_queue(_ group: nw_connection_group_t, _ queue: dispatch_queue_t)

nw_connection_group_set_receive_handler

nw_connection_group_set_receive_handler(group: Implements<OS_nw_connection_group> | SDKHandle, maximum_message_size: number, reject_oversized_messages: boolean, receive_handler?: (((arg0: (SDKHandle) | null, arg1: SDKHandle, arg2: boolean) => void)) | null): void

func nw_connection_group_set_receive_handler(_ group: nw_connection_group_t, _ maximum_message_size: UInt32, _ reject_oversized_messages: Bool, _ receive_handler: nw_connection_group_receive_handler_t?)

nw_connection_group_set_state_changed_handler

nw_connection_group_set_state_changed_handler(group: Implements<OS_nw_connection_group> | SDKHandle, state_changed_handler?: (((arg0: nw_connection_group_state_t, arg1: (SDKHandle) | null) => void)) | null): void

func nw_connection_group_set_state_changed_handler(_ group: nw_connection_group_t, _ state_changed_handler: nw_connection_group_state_changed_handler_t?)

nw_connection_group_start

nw_connection_group_start(group: Implements<OS_nw_connection_group> | SDKHandle): void

func nw_connection_group_start(_ group: nw_connection_group_t)

nw_connection_receive

nw_connection_receive(connection: Implements<OS_nw_connection> | SDKHandle, minimum_incomplete_length: number, maximum_length: number, completion: ((arg0: (SDKHandle) | null, arg1: (SDKHandle) | null, arg2: boolean, arg3: (SDKHandle) | null) => void)): void

func nw_connection_receive(_ connection: nw_connection_t, _ minimum_incomplete_length: UInt32, _ maximum_length: UInt32, _ completion: @escaping nw_connection_receive_completion_t)

nw_connection_receive_message

nw_connection_receive_message(connection: Implements<OS_nw_connection> | SDKHandle, completion: ((arg0: (SDKHandle) | null, arg1: (SDKHandle) | null, arg2: boolean, arg3: (SDKHandle) | null) => void)): void

func nw_connection_receive_message(_ connection: nw_connection_t, _ completion: @escaping nw_connection_receive_completion_t)

nw_connection_restart

nw_connection_restart(connection: Implements<OS_nw_connection> | SDKHandle): void

func nw_connection_restart(_ connection: nw_connection_t)

nw_connection_send

nw_connection_send(connection: Implements<OS_nw_connection> | SDKHandle, content: (SDKHandle) | null, context: Implements<OS_nw_content_context> | SDKHandle, is_complete: boolean, completion: ((arg0: (SDKHandle) | null) => void)): void

func nw_connection_send(_ connection: nw_connection_t, _ content: dispatch_data_t?, _ context: nw_content_context_t, _ is_complete: Bool, _ completion: @escaping nw_connection_send_completion_t)

nw_connection_set_better_path_available_handler

nw_connection_set_better_path_available_handler(connection: Implements<OS_nw_connection> | SDKHandle, handler?: (((arg0: boolean) => void)) | null): void

func nw_connection_set_better_path_available_handler(_ connection: nw_connection_t, _ handler: nw_connection_boolean_event_handler_t?)

nw_connection_set_path_changed_handler

nw_connection_set_path_changed_handler(connection: Implements<OS_nw_connection> | SDKHandle, handler?: (((arg0: SDKHandle) => void)) | null): void

func nw_connection_set_path_changed_handler(_ connection: nw_connection_t, _ handler: nw_connection_path_event_handler_t?)

nw_connection_set_queue

nw_connection_set_queue(connection: Implements<OS_nw_connection> | SDKHandle, queue: _Dispatch_DispatchQueue): void

func nw_connection_set_queue(_ connection: nw_connection_t, _ queue: dispatch_queue_t)

nw_connection_set_state_changed_handler

nw_connection_set_state_changed_handler(connection: Implements<OS_nw_connection> | SDKHandle, handler?: (((arg0: nw_connection_state_t, arg1: (SDKHandle) | null) => void)) | null): void

func nw_connection_set_state_changed_handler(_ connection: nw_connection_t, _ handler: nw_connection_state_changed_handler_t?)

nw_connection_set_viability_changed_handler

nw_connection_set_viability_changed_handler(connection: Implements<OS_nw_connection> | SDKHandle, handler?: (((arg0: boolean) => void)) | null): void

func nw_connection_set_viability_changed_handler(_ connection: nw_connection_t, _ handler: nw_connection_boolean_event_handler_t?)

nw_connection_start

nw_connection_start(connection: Implements<OS_nw_connection> | SDKHandle): void

func nw_connection_start(_ connection: nw_connection_t)

nw_content_context_copy_antecedent

nw_content_context_copy_antecedent(context: Implements<OS_nw_content_context> | SDKHandle): (SDKHandle) | null

func nw_content_context_copy_antecedent(_ context: nw_content_context_t) -> nw_content_context_t?

nw_content_context_copy_protocol_metadata

nw_content_context_copy_protocol_metadata(context: Implements<OS_nw_content_context> | SDKHandle, protocol: Implements<OS_nw_protocol_definition> | SDKHandle): (SDKHandle) | null

func nw_content_context_copy_protocol_metadata(_ context: nw_content_context_t, _ protocol: nw_protocol_definition_t) -> nw_protocol_metadata_t?

nw_content_context_create

nw_content_context_create(context_identifier: SDKHandle): SDKHandle

func nw_content_context_create(_ context_identifier: UnsafePointer<CChar>) -> nw_content_context_t

nw_content_context_foreach_protocol_metadata

nw_content_context_foreach_protocol_metadata(context: Implements<OS_nw_content_context> | SDKHandle, foreach_block: ((arg0: SDKHandle, arg1: SDKHandle) => void)): void

func nw_content_context_foreach_protocol_metadata(_ context: nw_content_context_t, _ foreach_block: @escaping (nw_protocol_definition_t, nw_protocol_metadata_t) -> Void)

nw_content_context_get_expiration_milliseconds

nw_content_context_get_expiration_milliseconds(context: Implements<OS_nw_content_context> | SDKHandle): number

func nw_content_context_get_expiration_milliseconds(_ context: nw_content_context_t) -> UInt64

nw_content_context_get_identifier

nw_content_context_get_identifier(context: Implements<OS_nw_content_context> | SDKHandle): SDKHandle

func nw_content_context_get_identifier(_ context: nw_content_context_t) -> UnsafePointer<CChar>

nw_content_context_get_is_final

nw_content_context_get_is_final(context: Implements<OS_nw_content_context> | SDKHandle): boolean

func nw_content_context_get_is_final(_ context: nw_content_context_t) -> Bool

nw_content_context_get_relative_priority

nw_content_context_get_relative_priority(context: Implements<OS_nw_content_context> | SDKHandle): number

func nw_content_context_get_relative_priority(_ context: nw_content_context_t) -> Double

nw_content_context_set_antecedent

nw_content_context_set_antecedent(context: Implements<OS_nw_content_context> | SDKHandle, antecedent_context?: (Implements<OS_nw_content_context> | SDKHandle) | null): void

func nw_content_context_set_antecedent(_ context: nw_content_context_t, _ antecedent_context: nw_content_context_t?)

nw_content_context_set_expiration_milliseconds

nw_content_context_set_expiration_milliseconds(context: Implements<OS_nw_content_context> | SDKHandle, expiration_milliseconds: number): void

func nw_content_context_set_expiration_milliseconds(_ context: nw_content_context_t, _ expiration_milliseconds: UInt64)

nw_content_context_set_is_final

nw_content_context_set_is_final(context: Implements<OS_nw_content_context> | SDKHandle, is_final: boolean): void

func nw_content_context_set_is_final(_ context: nw_content_context_t, _ is_final: Bool)

nw_content_context_set_metadata_for_protocol

nw_content_context_set_metadata_for_protocol(context: Implements<OS_nw_content_context> | SDKHandle, protocol_metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): void

func nw_content_context_set_metadata_for_protocol(_ context: nw_content_context_t, _ protocol_metadata: nw_protocol_metadata_t)

nw_content_context_set_relative_priority

nw_content_context_set_relative_priority(context: Implements<OS_nw_content_context> | SDKHandle, relative_priority: number): void

func nw_content_context_set_relative_priority(_ context: nw_content_context_t, _ relative_priority: Double)

nw_data_transfer_report_collect

nw_data_transfer_report_collect(report: Implements<OS_nw_data_transfer_report> | SDKHandle, queue: _Dispatch_DispatchQueue, collect_block: ((arg0: SDKHandle) => void)): void

func nw_data_transfer_report_collect(_ report: nw_data_transfer_report_t, _ queue: dispatch_queue_t, _ collect_block: @escaping nw_data_transfer_report_collect_block_t)

nw_data_transfer_report_copy_path_interface

nw_data_transfer_report_copy_path_interface(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): SDKHandle

func nw_data_transfer_report_copy_path_interface(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> nw_interface_t

nw_data_transfer_report_get_duration_milliseconds

nw_data_transfer_report_get_duration_milliseconds(report: Implements<OS_nw_data_transfer_report> | SDKHandle): number

func nw_data_transfer_report_get_duration_milliseconds(_ report: nw_data_transfer_report_t) -> UInt64

nw_data_transfer_report_get_path_count

nw_data_transfer_report_get_path_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle): number

func nw_data_transfer_report_get_path_count(_ report: nw_data_transfer_report_t) -> UInt32

nw_data_transfer_report_get_path_radio_type

nw_data_transfer_report_get_path_radio_type(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): nw_interface_radio_type_t

func nw_data_transfer_report_get_path_radio_type(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> nw_interface_radio_type_t

nw_data_transfer_report_get_received_application_byte_count

nw_data_transfer_report_get_received_application_byte_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_received_application_byte_count(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_received_ip_packet_count

nw_data_transfer_report_get_received_ip_packet_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_received_ip_packet_count(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_received_transport_byte_count

nw_data_transfer_report_get_received_transport_byte_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_received_transport_byte_count(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_received_transport_duplicate_byte_count

nw_data_transfer_report_get_received_transport_duplicate_byte_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_received_transport_duplicate_byte_count(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_received_transport_out_of_order_byte_count

nw_data_transfer_report_get_received_transport_out_of_order_byte_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_received_transport_out_of_order_byte_count(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_sent_application_byte_count

nw_data_transfer_report_get_sent_application_byte_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_sent_application_byte_count(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_sent_ip_packet_count

nw_data_transfer_report_get_sent_ip_packet_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_sent_ip_packet_count(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_sent_transport_byte_count

nw_data_transfer_report_get_sent_transport_byte_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_sent_transport_byte_count(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_sent_transport_retransmitted_byte_count

nw_data_transfer_report_get_sent_transport_retransmitted_byte_count(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_sent_transport_retransmitted_byte_count(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_state

nw_data_transfer_report_get_state(report: Implements<OS_nw_data_transfer_report> | SDKHandle): nw_data_transfer_report_state_t

func nw_data_transfer_report_get_state(_ report: nw_data_transfer_report_t) -> nw_data_transfer_report_state_t

nw_data_transfer_report_get_transport_minimum_rtt_milliseconds

nw_data_transfer_report_get_transport_minimum_rtt_milliseconds(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_transport_minimum_rtt_milliseconds(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_transport_rtt_variance

nw_data_transfer_report_get_transport_rtt_variance(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_transport_rtt_variance(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_data_transfer_report_get_transport_smoothed_rtt_milliseconds

nw_data_transfer_report_get_transport_smoothed_rtt_milliseconds(report: Implements<OS_nw_data_transfer_report> | SDKHandle, path_index: number): number

func nw_data_transfer_report_get_transport_smoothed_rtt_milliseconds(_ report: nw_data_transfer_report_t, _ path_index: UInt32) -> UInt64

nw_endpoint_copy_address_string

nw_endpoint_copy_address_string(endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_endpoint_copy_address_string(_ endpoint: nw_endpoint_t) -> UnsafeMutablePointer<CChar>

nw_endpoint_copy_port_string

nw_endpoint_copy_port_string(endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_endpoint_copy_port_string(_ endpoint: nw_endpoint_t) -> UnsafeMutablePointer<CChar>

nw_endpoint_copy_txt_record

nw_endpoint_copy_txt_record(endpoint: Implements<OS_nw_endpoint> | SDKHandle): (SDKHandle) | null

func nw_endpoint_copy_txt_record(_ endpoint: nw_endpoint_t) -> nw_txt_record_t?

nw_endpoint_create_address

nw_endpoint_create_address(address: SDKHandle): SDKHandle

func nw_endpoint_create_address(_ address: UnsafePointer<sockaddr>) -> nw_endpoint_t

nw_endpoint_create_bonjour_service

nw_endpoint_create_bonjour_service(name: SDKHandle, type: SDKHandle, domain: SDKHandle): SDKHandle

func nw_endpoint_create_bonjour_service(_ name: UnsafePointer<CChar>, _ type: UnsafePointer<CChar>, _ domain: UnsafePointer<CChar>) -> nw_endpoint_t

nw_endpoint_create_host

nw_endpoint_create_host(hostname: SDKHandle, port: SDKHandle): SDKHandle

func nw_endpoint_create_host(_ hostname: UnsafePointer<CChar>, _ port: UnsafePointer<CChar>) -> nw_endpoint_t

nw_endpoint_create_url

nw_endpoint_create_url(url: SDKHandle): SDKHandle

func nw_endpoint_create_url(_ url: UnsafePointer<CChar>) -> nw_endpoint_t

nw_endpoint_get_address

nw_endpoint_get_address(endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_endpoint_get_address(_ endpoint: nw_endpoint_t) -> UnsafePointer<sockaddr>

nw_endpoint_get_bonjour_service_domain

nw_endpoint_get_bonjour_service_domain(endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_endpoint_get_bonjour_service_domain(_ endpoint: nw_endpoint_t) -> UnsafePointer<CChar>

nw_endpoint_get_bonjour_service_name

nw_endpoint_get_bonjour_service_name(endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_endpoint_get_bonjour_service_name(_ endpoint: nw_endpoint_t) -> UnsafePointer<CChar>

nw_endpoint_get_bonjour_service_type

nw_endpoint_get_bonjour_service_type(endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_endpoint_get_bonjour_service_type(_ endpoint: nw_endpoint_t) -> UnsafePointer<CChar>

nw_endpoint_get_hostname

nw_endpoint_get_hostname(endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_endpoint_get_hostname(_ endpoint: nw_endpoint_t) -> UnsafePointer<CChar>

nw_endpoint_get_port

nw_endpoint_get_port(endpoint: Implements<OS_nw_endpoint> | SDKHandle): number

func nw_endpoint_get_port(_ endpoint: nw_endpoint_t) -> UInt16

nw_endpoint_get_signature

nw_endpoint_get_signature(endpoint: Implements<OS_nw_endpoint> | SDKHandle, out_signature_length: SDKHandle): (SDKHandle) | null

func nw_endpoint_get_signature(_ endpoint: nw_endpoint_t, _ out_signature_length: UnsafeMutablePointer<Int>) -> UnsafePointer<UInt8>?

nw_endpoint_get_type

nw_endpoint_get_type(endpoint: Implements<OS_nw_endpoint> | SDKHandle): nw_endpoint_type_t

func nw_endpoint_get_type(_ endpoint: nw_endpoint_t) -> nw_endpoint_type_t

nw_endpoint_get_url

nw_endpoint_get_url(endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_endpoint_get_url(_ endpoint: nw_endpoint_t) -> UnsafePointer<CChar>

nw_error_copy_cf_error

nw_error_copy_cf_error(error: Implements<OS_nw_error> | SDKHandle): SDKHandle

func nw_error_copy_cf_error(_ error: nw_error_t) -> Unmanaged<CFError>

nw_error_get_error_code

nw_error_get_error_code(error: Implements<OS_nw_error> | SDKHandle): number

func nw_error_get_error_code(_ error: nw_error_t) -> Int32

nw_error_get_error_domain

nw_error_get_error_domain(error: Implements<OS_nw_error> | SDKHandle): nw_error_domain_t

func nw_error_get_error_domain(_ error: nw_error_t) -> nw_error_domain_t

nw_establishment_report_copy_proxy_endpoint

nw_establishment_report_copy_proxy_endpoint(report: Implements<OS_nw_establishment_report> | SDKHandle): (SDKHandle) | null

func nw_establishment_report_copy_proxy_endpoint(_ report: nw_establishment_report_t) -> nw_endpoint_t?

nw_establishment_report_get_attempt_started_after_milliseconds

nw_establishment_report_get_attempt_started_after_milliseconds(report: Implements<OS_nw_establishment_report> | SDKHandle): number

func nw_establishment_report_get_attempt_started_after_milliseconds(_ report: nw_establishment_report_t) -> UInt64

nw_establishment_report_get_duration_milliseconds

nw_establishment_report_get_duration_milliseconds(report: Implements<OS_nw_establishment_report> | SDKHandle): number

func nw_establishment_report_get_duration_milliseconds(_ report: nw_establishment_report_t) -> UInt64

nw_establishment_report_get_previous_attempt_count

nw_establishment_report_get_previous_attempt_count(report: Implements<OS_nw_establishment_report> | SDKHandle): number

func nw_establishment_report_get_previous_attempt_count(_ report: nw_establishment_report_t) -> UInt32

nw_establishment_report_get_proxy_configured

nw_establishment_report_get_proxy_configured(report: Implements<OS_nw_establishment_report> | SDKHandle): boolean

func nw_establishment_report_get_proxy_configured(_ report: nw_establishment_report_t) -> Bool

nw_establishment_report_get_used_proxy

nw_establishment_report_get_used_proxy(report: Implements<OS_nw_establishment_report> | SDKHandle): boolean

func nw_establishment_report_get_used_proxy(_ report: nw_establishment_report_t) -> Bool

nw_framer_async

nw_framer_async(framer: Implements<OS_nw_framer> | SDKHandle, async_block: (() => void)): void

func nw_framer_async(_ framer: nw_framer_t, _ async_block: @escaping nw_framer_block_t)

nw_framer_copy_local_endpoint

nw_framer_copy_local_endpoint(framer: Implements<OS_nw_framer> | SDKHandle): SDKHandle

func nw_framer_copy_local_endpoint(_ framer: nw_framer_t) -> nw_endpoint_t

nw_framer_copy_options

nw_framer_copy_options(framer: Implements<OS_nw_framer> | SDKHandle): SDKHandle

func nw_framer_copy_options(_ framer: nw_framer_t) -> nw_protocol_options_t

nw_framer_copy_parameters

nw_framer_copy_parameters(framer: Implements<OS_nw_framer> | SDKHandle): SDKHandle

func nw_framer_copy_parameters(_ framer: nw_framer_t) -> nw_parameters_t

nw_framer_copy_remote_endpoint

nw_framer_copy_remote_endpoint(framer: Implements<OS_nw_framer> | SDKHandle): SDKHandle

func nw_framer_copy_remote_endpoint(_ framer: nw_framer_t) -> nw_endpoint_t

nw_framer_create_options

nw_framer_create_options(framer_definition: Implements<OS_nw_protocol_definition> | SDKHandle): SDKHandle

func nw_framer_create_options(_ framer_definition: nw_protocol_definition_t) -> nw_protocol_options_t

nw_framer_deliver_input

nw_framer_deliver_input(framer: Implements<OS_nw_framer> | SDKHandle, input_buffer: SDKHandle, input_length: number, message: Implements<OS_nw_protocol_metadata> | SDKHandle, is_complete: boolean): void

func nw_framer_deliver_input(_ framer: nw_framer_t, _ input_buffer: UnsafePointer<UInt8>, _ input_length: Int, _ message: nw_framer_message_t, _ is_complete: Bool)

nw_framer_deliver_input_no_copy

nw_framer_deliver_input_no_copy(framer: Implements<OS_nw_framer> | SDKHandle, input_length: number, message: Implements<OS_nw_protocol_metadata> | SDKHandle, is_complete: boolean): boolean

func nw_framer_deliver_input_no_copy(_ framer: nw_framer_t, _ input_length: Int, _ message: nw_framer_message_t, _ is_complete: Bool) -> Bool

nw_framer_mark_failed_with_error

nw_framer_mark_failed_with_error(framer: Implements<OS_nw_framer> | SDKHandle, error_code: number): void

func nw_framer_mark_failed_with_error(_ framer: nw_framer_t, _ error_code: Int32)

nw_framer_mark_ready

nw_framer_mark_ready(framer: Implements<OS_nw_framer> | SDKHandle): void

func nw_framer_mark_ready(_ framer: nw_framer_t)

nw_framer_message_copy_object_value

nw_framer_message_copy_object_value(message: Implements<OS_nw_protocol_metadata> | SDKHandle, key: SDKHandle): (unknown) | null

func nw_framer_message_copy_object_value(_ message: nw_framer_message_t, _ key: UnsafePointer<CChar>) -> Any?

nw_framer_message_create

nw_framer_message_create(framer: Implements<OS_nw_framer> | SDKHandle): SDKHandle

func nw_framer_message_create(_ framer: nw_framer_t) -> nw_framer_message_t

nw_framer_message_set_object_value

nw_framer_message_set_object_value(message: Implements<OS_nw_protocol_metadata> | SDKHandle, key: SDKHandle, value?: (unknown) | null): void

func nw_framer_message_set_object_value(_ message: nw_framer_message_t, _ key: UnsafePointer<CChar>, _ value: Any?)

nw_framer_message_set_value

nw_framer_message_set_value(message: Implements<OS_nw_protocol_metadata> | SDKHandle, key: SDKHandle, value?: (SDKHandle) | null, dispose_value?: (((arg0: SDKHandle) => void)) | null): void

func nw_framer_message_set_value(_ message: nw_framer_message_t, _ key: UnsafePointer<CChar>, _ value: UnsafeMutableRawPointer?, _ dispose_value: nw_framer_message_dispose_value_t?)

nw_framer_options_copy_object_value

nw_framer_options_copy_object_value(options: Implements<OS_nw_protocol_options> | SDKHandle, key: SDKHandle): (unknown) | null

func nw_framer_options_copy_object_value(_ options: nw_protocol_options_t, _ key: UnsafePointer<CChar>) -> Any?

nw_framer_options_set_object_value

nw_framer_options_set_object_value(options: Implements<OS_nw_protocol_options> | SDKHandle, key: SDKHandle, value?: (unknown) | null): void

func nw_framer_options_set_object_value(_ options: nw_protocol_options_t, _ key: UnsafePointer<CChar>, _ value: Any?)

nw_framer_pass_through_input

nw_framer_pass_through_input(framer: Implements<OS_nw_framer> | SDKHandle): void

func nw_framer_pass_through_input(_ framer: nw_framer_t)

nw_framer_pass_through_output

nw_framer_pass_through_output(framer: Implements<OS_nw_framer> | SDKHandle): void

func nw_framer_pass_through_output(_ framer: nw_framer_t)

nw_framer_prepend_application_protocol

nw_framer_prepend_application_protocol(framer: Implements<OS_nw_framer> | SDKHandle, protocol_options: Implements<OS_nw_protocol_options> | SDKHandle): boolean

func nw_framer_prepend_application_protocol(_ framer: nw_framer_t, _ protocol_options: nw_protocol_options_t) -> Bool

nw_framer_protocol_create_message

nw_framer_protocol_create_message(definition: Implements<OS_nw_protocol_definition> | SDKHandle): SDKHandle

func nw_framer_protocol_create_message(_ definition: nw_protocol_definition_t) -> nw_framer_message_t

nw_framer_schedule_wakeup

nw_framer_schedule_wakeup(framer: Implements<OS_nw_framer> | SDKHandle, milliseconds: number): void

func nw_framer_schedule_wakeup(_ framer: nw_framer_t, _ milliseconds: UInt64)

nw_framer_set_cleanup_handler

nw_framer_set_cleanup_handler(framer: Implements<OS_nw_framer> | SDKHandle, cleanup_handler: ((arg0: SDKHandle) => void)): void

func nw_framer_set_cleanup_handler(_ framer: nw_framer_t, _ cleanup_handler: @escaping nw_framer_cleanup_handler_t)

nw_framer_set_output_handler

nw_framer_set_output_handler(framer: Implements<OS_nw_framer> | SDKHandle, output_handler: ((arg0: SDKHandle, arg1: SDKHandle, arg2: number, arg3: boolean) => void)): void

func nw_framer_set_output_handler(_ framer: nw_framer_t, _ output_handler: @escaping nw_framer_output_handler_t)

nw_framer_set_wakeup_handler

nw_framer_set_wakeup_handler(framer: Implements<OS_nw_framer> | SDKHandle, wakeup_handler: ((arg0: SDKHandle) => void)): void

func nw_framer_set_wakeup_handler(_ framer: nw_framer_t, _ wakeup_handler: @escaping nw_framer_wakeup_handler_t)

nw_framer_write_output

nw_framer_write_output(framer: Implements<OS_nw_framer> | SDKHandle, output_buffer: SDKHandle, output_length: number): void

func nw_framer_write_output(_ framer: nw_framer_t, _ output_buffer: UnsafePointer<UInt8>, _ output_length: Int)

nw_framer_write_output_data

nw_framer_write_output_data(framer: Implements<OS_nw_framer> | SDKHandle, output_data: SDKHandle): void

func nw_framer_write_output_data(_ framer: nw_framer_t, _ output_data: dispatch_data_t)

nw_framer_write_output_no_copy

nw_framer_write_output_no_copy(framer: Implements<OS_nw_framer> | SDKHandle, output_length: number): boolean

func nw_framer_write_output_no_copy(_ framer: nw_framer_t, _ output_length: Int) -> Bool

nw_group_descriptor_add_endpoint

nw_group_descriptor_add_endpoint(descriptor: Implements<OS_nw_group_descriptor> | SDKHandle, endpoint: Implements<OS_nw_endpoint> | SDKHandle): boolean

func nw_group_descriptor_add_endpoint(_ descriptor: nw_group_descriptor_t, _ endpoint: nw_endpoint_t) -> Bool

nw_group_descriptor_create_multicast

nw_group_descriptor_create_multicast(multicast_group: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_group_descriptor_create_multicast(_ multicast_group: nw_endpoint_t) -> nw_group_descriptor_t

nw_group_descriptor_create_multiplex

nw_group_descriptor_create_multiplex(remote_endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_group_descriptor_create_multiplex(_ remote_endpoint: nw_endpoint_t) -> nw_group_descriptor_t

nw_interface_get_index

nw_interface_get_index(interface_: Implements<OS_nw_interface> | SDKHandle): number

func nw_interface_get_index(_ interface: nw_interface_t) -> UInt32

nw_interface_get_name

nw_interface_get_name(interface_: Implements<OS_nw_interface> | SDKHandle): SDKHandle

func nw_interface_get_name(_ interface: nw_interface_t) -> UnsafePointer<CChar>

nw_interface_get_type

nw_interface_get_type(interface_: Implements<OS_nw_interface> | SDKHandle): nw_interface_type_t

func nw_interface_get_type(_ interface: nw_interface_t) -> nw_interface_type_t

nw_ip_create_metadata

nw_ip_create_metadata(): SDKHandle

func nw_ip_create_metadata() -> nw_protocol_metadata_t

nw_ip_metadata_get_ecn_flag

nw_ip_metadata_get_ecn_flag(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): nw_ip_ecn_flag_t

func nw_ip_metadata_get_ecn_flag(_ metadata: nw_protocol_metadata_t) -> nw_ip_ecn_flag_t

nw_ip_metadata_get_receive_time

nw_ip_metadata_get_receive_time(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_ip_metadata_get_receive_time(_ metadata: nw_protocol_metadata_t) -> UInt64

nw_ip_metadata_get_service_class

nw_ip_metadata_get_service_class(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): nw_service_class_t

func nw_ip_metadata_get_service_class(_ metadata: nw_protocol_metadata_t) -> nw_service_class_t

nw_ip_metadata_set_ecn_flag

nw_ip_metadata_set_ecn_flag(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, ecn_flag: nw_ip_ecn_flag_t): void

func nw_ip_metadata_set_ecn_flag(_ metadata: nw_protocol_metadata_t, _ ecn_flag: nw_ip_ecn_flag_t)

nw_ip_metadata_set_service_class

nw_ip_metadata_set_service_class(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, service_class: nw_service_class_t): void

func nw_ip_metadata_set_service_class(_ metadata: nw_protocol_metadata_t, _ service_class: nw_service_class_t)

nw_ip_options_set_calculate_receive_time

nw_ip_options_set_calculate_receive_time(options: Implements<OS_nw_protocol_options> | SDKHandle, calculate_receive_time: boolean): void

func nw_ip_options_set_calculate_receive_time(_ options: nw_protocol_options_t, _ calculate_receive_time: Bool)

nw_ip_options_set_disable_fragmentation

nw_ip_options_set_disable_fragmentation(options: Implements<OS_nw_protocol_options> | SDKHandle, disable_fragmentation: boolean): void

func nw_ip_options_set_disable_fragmentation(_ options: nw_protocol_options_t, _ disable_fragmentation: Bool)

nw_ip_options_set_disable_multicast_loopback

nw_ip_options_set_disable_multicast_loopback(options: Implements<OS_nw_protocol_options> | SDKHandle, disable_multicast_loopback: boolean): void

func nw_ip_options_set_disable_multicast_loopback(_ options: nw_protocol_options_t, _ disable_multicast_loopback: Bool)

nw_ip_options_set_hop_limit

nw_ip_options_set_hop_limit(options: Implements<OS_nw_protocol_options> | SDKHandle, hop_limit: number): void

func nw_ip_options_set_hop_limit(_ options: nw_protocol_options_t, _ hop_limit: UInt8)

nw_ip_options_set_local_address_preference

nw_ip_options_set_local_address_preference(options: Implements<OS_nw_protocol_options> | SDKHandle, preference: nw_ip_local_address_preference_t): void

func nw_ip_options_set_local_address_preference(_ options: nw_protocol_options_t, _ preference: nw_ip_local_address_preference_t)

nw_ip_options_set_use_minimum_mtu

nw_ip_options_set_use_minimum_mtu(options: Implements<OS_nw_protocol_options> | SDKHandle, use_minimum_mtu: boolean): void

func nw_ip_options_set_use_minimum_mtu(_ options: nw_protocol_options_t, _ use_minimum_mtu: Bool)

nw_ip_options_set_version

nw_ip_options_set_version(options: Implements<OS_nw_protocol_options> | SDKHandle, version: nw_ip_version_t): void

func nw_ip_options_set_version(_ options: nw_protocol_options_t, _ version: nw_ip_version_t)

nw_listener_cancel

nw_listener_cancel(listener: Implements<OS_nw_listener> | SDKHandle): void

func nw_listener_cancel(_ listener: nw_listener_t)

nw_listener_create

nw_listener_create(parameters: Implements<OS_nw_parameters> | SDKHandle): (SDKHandle) | null

func nw_listener_create(_ parameters: nw_parameters_t) -> nw_listener_t?

nw_listener_create_with_connection

nw_listener_create_with_connection(connection: Implements<OS_nw_connection> | SDKHandle, parameters: Implements<OS_nw_parameters> | SDKHandle): (SDKHandle) | null

func nw_listener_create_with_connection(_ connection: nw_connection_t, _ parameters: nw_parameters_t) -> nw_listener_t?

nw_listener_create_with_port

nw_listener_create_with_port(port: SDKHandle, parameters: Implements<OS_nw_parameters> | SDKHandle): (SDKHandle) | null

func nw_listener_create_with_port(_ port: UnsafePointer<CChar>, _ parameters: nw_parameters_t) -> nw_listener_t?

nw_listener_get_new_connection_limit

nw_listener_get_new_connection_limit(listener: Implements<OS_nw_listener> | SDKHandle): number

func nw_listener_get_new_connection_limit(_ listener: nw_listener_t) -> UInt32

nw_listener_get_port

nw_listener_get_port(listener: Implements<OS_nw_listener> | SDKHandle): number

func nw_listener_get_port(_ listener: nw_listener_t) -> UInt16

nw_listener_set_advertise_descriptor

nw_listener_set_advertise_descriptor(listener: Implements<OS_nw_listener> | SDKHandle, advertise_descriptor?: (Implements<OS_nw_advertise_descriptor> | SDKHandle) | null): void

func nw_listener_set_advertise_descriptor(_ listener: nw_listener_t, _ advertise_descriptor: nw_advertise_descriptor_t?)

nw_listener_set_advertised_endpoint_changed_handler

nw_listener_set_advertised_endpoint_changed_handler(listener: Implements<OS_nw_listener> | SDKHandle, handler?: (((arg0: SDKHandle, arg1: boolean) => void)) | null): void

func nw_listener_set_advertised_endpoint_changed_handler(_ listener: nw_listener_t, _ handler: nw_listener_advertised_endpoint_changed_handler_t?)

nw_listener_set_new_connection_group_handler

nw_listener_set_new_connection_group_handler(listener: Implements<OS_nw_listener> | SDKHandle, handler?: (((arg0: SDKHandle) => void)) | null): void

func nw_listener_set_new_connection_group_handler(_ listener: nw_listener_t, _ handler: nw_listener_new_connection_group_handler_t?)

nw_listener_set_new_connection_handler

nw_listener_set_new_connection_handler(listener: Implements<OS_nw_listener> | SDKHandle, handler?: (((arg0: SDKHandle) => void)) | null): void

func nw_listener_set_new_connection_handler(_ listener: nw_listener_t, _ handler: nw_listener_new_connection_handler_t?)

nw_listener_set_new_connection_limit

nw_listener_set_new_connection_limit(listener: Implements<OS_nw_listener> | SDKHandle, new_connection_limit: number): void

func nw_listener_set_new_connection_limit(_ listener: nw_listener_t, _ new_connection_limit: UInt32)

nw_listener_set_queue

nw_listener_set_queue(listener: Implements<OS_nw_listener> | SDKHandle, queue: _Dispatch_DispatchQueue): void

func nw_listener_set_queue(_ listener: nw_listener_t, _ queue: dispatch_queue_t)

nw_listener_set_state_changed_handler

nw_listener_set_state_changed_handler(listener: Implements<OS_nw_listener> | SDKHandle, handler?: (((arg0: nw_listener_state_t, arg1: (SDKHandle) | null) => void)) | null): void

func nw_listener_set_state_changed_handler(_ listener: nw_listener_t, _ handler: nw_listener_state_changed_handler_t?)

nw_listener_start

nw_listener_start(listener: Implements<OS_nw_listener> | SDKHandle): void

func nw_listener_start(_ listener: nw_listener_t)

nw_multicast_group_descriptor_get_disable_unicast_traffic

nw_multicast_group_descriptor_get_disable_unicast_traffic(multicast_descriptor: Implements<OS_nw_group_descriptor> | SDKHandle): boolean

func nw_multicast_group_descriptor_get_disable_unicast_traffic(_ multicast_descriptor: nw_group_descriptor_t) -> Bool

nw_multicast_group_descriptor_set_disable_unicast_traffic

nw_multicast_group_descriptor_set_disable_unicast_traffic(multicast_descriptor: Implements<OS_nw_group_descriptor> | SDKHandle, disable_unicast_traffic: boolean): void

func nw_multicast_group_descriptor_set_disable_unicast_traffic(_ multicast_descriptor: nw_group_descriptor_t, _ disable_unicast_traffic: Bool)

nw_multicast_group_descriptor_set_specific_source

nw_multicast_group_descriptor_set_specific_source(multicast_descriptor: Implements<OS_nw_group_descriptor> | SDKHandle, source: Implements<OS_nw_endpoint> | SDKHandle): void

func nw_multicast_group_descriptor_set_specific_source(_ multicast_descriptor: nw_group_descriptor_t, _ source: nw_endpoint_t)

nw_parameters_clear_prohibited_interface_types

nw_parameters_clear_prohibited_interface_types(parameters: Implements<OS_nw_parameters> | SDKHandle): void

func nw_parameters_clear_prohibited_interface_types(_ parameters: nw_parameters_t)

nw_parameters_clear_prohibited_interfaces

nw_parameters_clear_prohibited_interfaces(parameters: Implements<OS_nw_parameters> | SDKHandle): void

func nw_parameters_clear_prohibited_interfaces(_ parameters: nw_parameters_t)

nw_parameters_copy

nw_parameters_copy(parameters: Implements<OS_nw_parameters> | SDKHandle): SDKHandle

func nw_parameters_copy(_ parameters: nw_parameters_t) -> nw_parameters_t

nw_parameters_copy_default_protocol_stack

nw_parameters_copy_default_protocol_stack(parameters: Implements<OS_nw_parameters> | SDKHandle): SDKHandle

func nw_parameters_copy_default_protocol_stack(_ parameters: nw_parameters_t) -> nw_protocol_stack_t

nw_parameters_copy_local_endpoint

nw_parameters_copy_local_endpoint(parameters: Implements<OS_nw_parameters> | SDKHandle): (SDKHandle) | null

func nw_parameters_copy_local_endpoint(_ parameters: nw_parameters_t) -> nw_endpoint_t?

nw_parameters_copy_required_interface

nw_parameters_copy_required_interface(parameters: Implements<OS_nw_parameters> | SDKHandle): (SDKHandle) | null

func nw_parameters_copy_required_interface(_ parameters: nw_parameters_t) -> nw_interface_t?

nw_parameters_create

nw_parameters_create(): SDKHandle

func nw_parameters_create() -> nw_parameters_t

nw_parameters_create_application_service

nw_parameters_create_application_service(): SDKHandle

func nw_parameters_create_application_service() -> nw_parameters_t

nw_parameters_create_quic

nw_parameters_create_quic(configure_quic: ((arg0: SDKHandle) => void)): SDKHandle

func nw_parameters_create_quic(_ configure_quic: @escaping nw_parameters_configure_protocol_block_t) -> nw_parameters_t

nw_parameters_create_secure_tcp

nw_parameters_create_secure_tcp(configure_tls: ((arg0: SDKHandle) => void), configure_tcp: ((arg0: SDKHandle) => void)): SDKHandle

func nw_parameters_create_secure_tcp(_ configure_tls: @escaping nw_parameters_configure_protocol_block_t, _ configure_tcp: @escaping nw_parameters_configure_protocol_block_t) -> nw_parameters_t

nw_parameters_create_secure_udp

nw_parameters_create_secure_udp(configure_dtls: ((arg0: SDKHandle) => void), configure_udp: ((arg0: SDKHandle) => void)): SDKHandle

func nw_parameters_create_secure_udp(_ configure_dtls: @escaping nw_parameters_configure_protocol_block_t, _ configure_udp: @escaping nw_parameters_configure_protocol_block_t) -> nw_parameters_t

nw_parameters_get_allow_ultra_constrained

nw_parameters_get_allow_ultra_constrained(parameters: Implements<OS_nw_parameters> | SDKHandle): boolean

func nw_parameters_get_allow_ultra_constrained(_ parameters: nw_parameters_t) -> Bool

nw_parameters_get_attribution

nw_parameters_get_attribution(parameters: Implements<OS_nw_parameters> | SDKHandle): nw_parameters_attribution_t

func nw_parameters_get_attribution(_ parameters: nw_parameters_t) -> nw_parameters_attribution_t

nw_parameters_get_expired_dns_behavior

nw_parameters_get_expired_dns_behavior(parameters: Implements<OS_nw_parameters> | SDKHandle): nw_parameters_expired_dns_behavior_t

func nw_parameters_get_expired_dns_behavior(_ parameters: nw_parameters_t) -> nw_parameters_expired_dns_behavior_t

nw_parameters_get_fast_open_enabled

nw_parameters_get_fast_open_enabled(parameters: Implements<OS_nw_parameters> | SDKHandle): boolean

func nw_parameters_get_fast_open_enabled(_ parameters: nw_parameters_t) -> Bool

nw_parameters_get_include_peer_to_peer

nw_parameters_get_include_peer_to_peer(parameters: Implements<OS_nw_parameters> | SDKHandle): boolean

func nw_parameters_get_include_peer_to_peer(_ parameters: nw_parameters_t) -> Bool

nw_parameters_get_local_only

nw_parameters_get_local_only(parameters: Implements<OS_nw_parameters> | SDKHandle): boolean

func nw_parameters_get_local_only(_ parameters: nw_parameters_t) -> Bool

nw_parameters_get_multipath_service

nw_parameters_get_multipath_service(parameters: Implements<OS_nw_parameters> | SDKHandle): nw_multipath_service_t

func nw_parameters_get_multipath_service(_ parameters: nw_parameters_t) -> nw_multipath_service_t

nw_parameters_get_prefer_no_proxy

nw_parameters_get_prefer_no_proxy(parameters: Implements<OS_nw_parameters> | SDKHandle): boolean

func nw_parameters_get_prefer_no_proxy(_ parameters: nw_parameters_t) -> Bool

nw_parameters_get_prohibit_constrained

nw_parameters_get_prohibit_constrained(parameters: Implements<OS_nw_parameters> | SDKHandle): boolean

func nw_parameters_get_prohibit_constrained(_ parameters: nw_parameters_t) -> Bool

nw_parameters_get_prohibit_expensive

nw_parameters_get_prohibit_expensive(parameters: Implements<OS_nw_parameters> | SDKHandle): boolean

func nw_parameters_get_prohibit_expensive(_ parameters: nw_parameters_t) -> Bool

nw_parameters_get_required_interface_type

nw_parameters_get_required_interface_type(parameters: Implements<OS_nw_parameters> | SDKHandle): nw_interface_type_t

func nw_parameters_get_required_interface_type(_ parameters: nw_parameters_t) -> nw_interface_type_t

nw_parameters_get_reuse_local_address

nw_parameters_get_reuse_local_address(parameters: Implements<OS_nw_parameters> | SDKHandle): boolean

func nw_parameters_get_reuse_local_address(_ parameters: nw_parameters_t) -> Bool

nw_parameters_get_service_class

nw_parameters_get_service_class(parameters: Implements<OS_nw_parameters> | SDKHandle): nw_service_class_t

func nw_parameters_get_service_class(_ parameters: nw_parameters_t) -> nw_service_class_t

nw_parameters_prohibit_interface

nw_parameters_prohibit_interface(parameters: Implements<OS_nw_parameters> | SDKHandle, interface_: Implements<OS_nw_interface> | SDKHandle): void

func nw_parameters_prohibit_interface(_ parameters: nw_parameters_t, _ interface: nw_interface_t)

nw_parameters_prohibit_interface_type

nw_parameters_prohibit_interface_type(parameters: Implements<OS_nw_parameters> | SDKHandle, interface_type: nw_interface_type_t): void

func nw_parameters_prohibit_interface_type(_ parameters: nw_parameters_t, _ interface_type: nw_interface_type_t)

nw_parameters_require_interface

nw_parameters_require_interface(parameters: Implements<OS_nw_parameters> | SDKHandle, interface_?: (Implements<OS_nw_interface> | SDKHandle) | null): void

func nw_parameters_require_interface(_ parameters: nw_parameters_t, _ interface: nw_interface_t?)

nw_parameters_requires_dnssec_validation

nw_parameters_requires_dnssec_validation(parameters: Implements<OS_nw_parameters> | SDKHandle): boolean

func nw_parameters_requires_dnssec_validation(_ parameters: nw_parameters_t) -> Bool

nw_parameters_set_allow_ultra_constrained

nw_parameters_set_allow_ultra_constrained(parameters: Implements<OS_nw_parameters> | SDKHandle, allow_ultra_constrained: boolean): void

func nw_parameters_set_allow_ultra_constrained(_ parameters: nw_parameters_t, _ allow_ultra_constrained: Bool)

nw_parameters_set_attribution

nw_parameters_set_attribution(parameters: Implements<OS_nw_parameters> | SDKHandle, attribution: nw_parameters_attribution_t): void

func nw_parameters_set_attribution(_ parameters: nw_parameters_t, _ attribution: nw_parameters_attribution_t)

nw_parameters_set_expired_dns_behavior

nw_parameters_set_expired_dns_behavior(parameters: Implements<OS_nw_parameters> | SDKHandle, expired_dns_behavior: nw_parameters_expired_dns_behavior_t): void

func nw_parameters_set_expired_dns_behavior(_ parameters: nw_parameters_t, _ expired_dns_behavior: nw_parameters_expired_dns_behavior_t)

nw_parameters_set_fast_open_enabled

nw_parameters_set_fast_open_enabled(parameters: Implements<OS_nw_parameters> | SDKHandle, fast_open_enabled: boolean): void

func nw_parameters_set_fast_open_enabled(_ parameters: nw_parameters_t, _ fast_open_enabled: Bool)

nw_parameters_set_include_peer_to_peer

nw_parameters_set_include_peer_to_peer(parameters: Implements<OS_nw_parameters> | SDKHandle, include_peer_to_peer: boolean): void

func nw_parameters_set_include_peer_to_peer(_ parameters: nw_parameters_t, _ include_peer_to_peer: Bool)

nw_parameters_set_local_endpoint

nw_parameters_set_local_endpoint(parameters: Implements<OS_nw_parameters> | SDKHandle, local_endpoint?: (Implements<OS_nw_endpoint> | SDKHandle) | null): void

func nw_parameters_set_local_endpoint(_ parameters: nw_parameters_t, _ local_endpoint: nw_endpoint_t?)

nw_parameters_set_local_only

nw_parameters_set_local_only(parameters: Implements<OS_nw_parameters> | SDKHandle, local_only: boolean): void

func nw_parameters_set_local_only(_ parameters: nw_parameters_t, _ local_only: Bool)

nw_parameters_set_multipath_service

nw_parameters_set_multipath_service(parameters: Implements<OS_nw_parameters> | SDKHandle, multipath_service: nw_multipath_service_t): void

func nw_parameters_set_multipath_service(_ parameters: nw_parameters_t, _ multipath_service: nw_multipath_service_t)

nw_parameters_set_prefer_no_proxy

nw_parameters_set_prefer_no_proxy(parameters: Implements<OS_nw_parameters> | SDKHandle, prefer_no_proxy: boolean): void

func nw_parameters_set_prefer_no_proxy(_ parameters: nw_parameters_t, _ prefer_no_proxy: Bool)

nw_parameters_set_privacy_context

nw_parameters_set_privacy_context(parameters: Implements<OS_nw_parameters> | SDKHandle, privacy_context: Implements<OS_nw_privacy_context> | SDKHandle): void

func nw_parameters_set_privacy_context(_ parameters: nw_parameters_t, _ privacy_context: nw_privacy_context_t)

nw_parameters_set_prohibit_constrained

nw_parameters_set_prohibit_constrained(parameters: Implements<OS_nw_parameters> | SDKHandle, prohibit_constrained: boolean): void

func nw_parameters_set_prohibit_constrained(_ parameters: nw_parameters_t, _ prohibit_constrained: Bool)

nw_parameters_set_prohibit_expensive

nw_parameters_set_prohibit_expensive(parameters: Implements<OS_nw_parameters> | SDKHandle, prohibit_expensive: boolean): void

func nw_parameters_set_prohibit_expensive(_ parameters: nw_parameters_t, _ prohibit_expensive: Bool)

nw_parameters_set_required_interface_type

nw_parameters_set_required_interface_type(parameters: Implements<OS_nw_parameters> | SDKHandle, interface_type: nw_interface_type_t): void

func nw_parameters_set_required_interface_type(_ parameters: nw_parameters_t, _ interface_type: nw_interface_type_t)

nw_parameters_set_requires_dnssec_validation

nw_parameters_set_requires_dnssec_validation(parameters: Implements<OS_nw_parameters> | SDKHandle, requires_dnssec_validation: boolean): void

func nw_parameters_set_requires_dnssec_validation(_ parameters: nw_parameters_t, _ requires_dnssec_validation: Bool)

nw_parameters_set_reuse_local_address

nw_parameters_set_reuse_local_address(parameters: Implements<OS_nw_parameters> | SDKHandle, reuse_local_address: boolean): void

func nw_parameters_set_reuse_local_address(_ parameters: nw_parameters_t, _ reuse_local_address: Bool)

nw_parameters_set_service_class

nw_parameters_set_service_class(parameters: Implements<OS_nw_parameters> | SDKHandle, service_class: nw_service_class_t): void

func nw_parameters_set_service_class(_ parameters: nw_parameters_t, _ service_class: nw_service_class_t)

nw_path_copy_effective_local_endpoint

nw_path_copy_effective_local_endpoint(path: Implements<OS_nw_path> | SDKHandle): (SDKHandle) | null

func nw_path_copy_effective_local_endpoint(_ path: nw_path_t) -> nw_endpoint_t?

nw_path_copy_effective_remote_endpoint

nw_path_copy_effective_remote_endpoint(path: Implements<OS_nw_path> | SDKHandle): (SDKHandle) | null

func nw_path_copy_effective_remote_endpoint(_ path: nw_path_t) -> nw_endpoint_t?

nw_path_get_link_quality

nw_path_get_link_quality(path: Implements<OS_nw_path> | SDKHandle): nw_link_quality_t

func nw_path_get_link_quality(_ path: nw_path_t) -> nw_link_quality_t

nw_path_get_status

nw_path_get_status(path: Implements<OS_nw_path> | SDKHandle): nw_path_status_t

func nw_path_get_status(_ path: nw_path_t) -> nw_path_status_t

nw_path_get_unsatisfied_reason

nw_path_get_unsatisfied_reason(path: Implements<OS_nw_path> | SDKHandle): nw_path_unsatisfied_reason_t

func nw_path_get_unsatisfied_reason(_ path: nw_path_t) -> nw_path_unsatisfied_reason_t

nw_path_has_dns

nw_path_has_dns(path: Implements<OS_nw_path> | SDKHandle): boolean

func nw_path_has_dns(_ path: nw_path_t) -> Bool

nw_path_has_ipv4

nw_path_has_ipv4(path: Implements<OS_nw_path> | SDKHandle): boolean

func nw_path_has_ipv4(_ path: nw_path_t) -> Bool

nw_path_has_ipv6

nw_path_has_ipv6(path: Implements<OS_nw_path> | SDKHandle): boolean

func nw_path_has_ipv6(_ path: nw_path_t) -> Bool

nw_path_is_constrained

nw_path_is_constrained(path: Implements<OS_nw_path> | SDKHandle): boolean

func nw_path_is_constrained(_ path: nw_path_t) -> Bool

nw_path_is_equal

nw_path_is_equal(path: Implements<OS_nw_path> | SDKHandle, other_path: Implements<OS_nw_path> | SDKHandle): boolean

func nw_path_is_equal(_ path: nw_path_t, _ other_path: nw_path_t) -> Bool

nw_path_is_expensive

nw_path_is_expensive(path: Implements<OS_nw_path> | SDKHandle): boolean

func nw_path_is_expensive(_ path: nw_path_t) -> Bool

nw_path_is_ultra_constrained

nw_path_is_ultra_constrained(path: Implements<OS_nw_path> | SDKHandle): boolean

func nw_path_is_ultra_constrained(_ path: nw_path_t) -> Bool

nw_path_monitor_cancel

nw_path_monitor_cancel(monitor: Implements<OS_nw_path_monitor> | SDKHandle): void

func nw_path_monitor_cancel(_ monitor: nw_path_monitor_t)

nw_path_monitor_create

nw_path_monitor_create(): SDKHandle

func nw_path_monitor_create() -> nw_path_monitor_t

nw_path_monitor_create_with_type

nw_path_monitor_create_with_type(required_interface_type: nw_interface_type_t): SDKHandle

func nw_path_monitor_create_with_type(_ required_interface_type: nw_interface_type_t) -> nw_path_monitor_t

nw_path_monitor_prohibit_interface_type

nw_path_monitor_prohibit_interface_type(monitor: Implements<OS_nw_path_monitor> | SDKHandle, interface_type: nw_interface_type_t): void

func nw_path_monitor_prohibit_interface_type(_ monitor: nw_path_monitor_t, _ interface_type: nw_interface_type_t)

nw_path_monitor_set_cancel_handler

nw_path_monitor_set_cancel_handler(monitor: Implements<OS_nw_path_monitor> | SDKHandle, cancel_handler: (() => void)): void

func nw_path_monitor_set_cancel_handler(_ monitor: nw_path_monitor_t, _ cancel_handler: @escaping nw_path_monitor_cancel_handler_t)

nw_path_monitor_set_queue

nw_path_monitor_set_queue(monitor: Implements<OS_nw_path_monitor> | SDKHandle, queue: _Dispatch_DispatchQueue): void

func nw_path_monitor_set_queue(_ monitor: nw_path_monitor_t, _ queue: dispatch_queue_t)

nw_path_monitor_set_update_handler

nw_path_monitor_set_update_handler(monitor: Implements<OS_nw_path_monitor> | SDKHandle, update_handler: ((arg0: SDKHandle) => void)): void

func nw_path_monitor_set_update_handler(_ monitor: nw_path_monitor_t, _ update_handler: @escaping nw_path_monitor_update_handler_t)

nw_path_monitor_start

nw_path_monitor_start(monitor: Implements<OS_nw_path_monitor> | SDKHandle): void

func nw_path_monitor_start(_ monitor: nw_path_monitor_t)

nw_path_uses_interface_type

nw_path_uses_interface_type(path: Implements<OS_nw_path> | SDKHandle, interface_type: nw_interface_type_t): boolean

func nw_path_uses_interface_type(_ path: nw_path_t, _ interface_type: nw_interface_type_t) -> Bool

nw_privacy_context_add_proxy

nw_privacy_context_add_proxy(privacy_context: Implements<OS_nw_privacy_context> | SDKHandle, proxy_config: Implements<OS_nw_proxy_config> | SDKHandle): void

func nw_privacy_context_add_proxy(_ privacy_context: nw_privacy_context_t, _ proxy_config: nw_proxy_config_t)

nw_privacy_context_clear_proxies

nw_privacy_context_clear_proxies(privacy_context: Implements<OS_nw_privacy_context> | SDKHandle): void

func nw_privacy_context_clear_proxies(_ privacy_context: nw_privacy_context_t)

nw_privacy_context_create

nw_privacy_context_create(description: SDKHandle): SDKHandle

func nw_privacy_context_create(_ description: UnsafePointer<CChar>) -> nw_privacy_context_t

nw_privacy_context_disable_logging

nw_privacy_context_disable_logging(privacy_context: Implements<OS_nw_privacy_context> | SDKHandle): void

func nw_privacy_context_disable_logging(_ privacy_context: nw_privacy_context_t)

nw_privacy_context_flush_cache

nw_privacy_context_flush_cache(privacy_context: Implements<OS_nw_privacy_context> | SDKHandle): void

func nw_privacy_context_flush_cache(_ privacy_context: nw_privacy_context_t)

nw_privacy_context_require_encrypted_name_resolution

nw_privacy_context_require_encrypted_name_resolution(privacy_context: Implements<OS_nw_privacy_context> | SDKHandle, require_encrypted_name_resolution: boolean, fallback_resolver_config?: (Implements<OS_nw_resolver_config> | SDKHandle) | null): void

func nw_privacy_context_require_encrypted_name_resolution(_ privacy_context: nw_privacy_context_t, _ require_encrypted_name_resolution: Bool, _ fallback_resolver_config: nw_resolver_config_t?)

nw_protocol_copy_ip_definition

nw_protocol_copy_ip_definition(): SDKHandle

func nw_protocol_copy_ip_definition() -> nw_protocol_definition_t

nw_protocol_copy_quic_definition

nw_protocol_copy_quic_definition(): SDKHandle

func nw_protocol_copy_quic_definition() -> nw_protocol_definition_t

nw_protocol_copy_tcp_definition

nw_protocol_copy_tcp_definition(): SDKHandle

func nw_protocol_copy_tcp_definition() -> nw_protocol_definition_t

nw_protocol_copy_tls_definition

nw_protocol_copy_tls_definition(): SDKHandle

func nw_protocol_copy_tls_definition() -> nw_protocol_definition_t

nw_protocol_copy_udp_definition

nw_protocol_copy_udp_definition(): SDKHandle

func nw_protocol_copy_udp_definition() -> nw_protocol_definition_t

nw_protocol_copy_ws_definition

nw_protocol_copy_ws_definition(): SDKHandle

func nw_protocol_copy_ws_definition() -> nw_protocol_definition_t

nw_protocol_definition_is_equal

nw_protocol_definition_is_equal(definition1: Implements<OS_nw_protocol_definition> | SDKHandle, definition2: Implements<OS_nw_protocol_definition> | SDKHandle): boolean

func nw_protocol_definition_is_equal(_ definition1: nw_protocol_definition_t, _ definition2: nw_protocol_definition_t) -> Bool

nw_protocol_metadata_copy_definition

nw_protocol_metadata_copy_definition(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): SDKHandle

func nw_protocol_metadata_copy_definition(_ metadata: nw_protocol_metadata_t) -> nw_protocol_definition_t

nw_protocol_metadata_is_framer_message

nw_protocol_metadata_is_framer_message(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): boolean

func nw_protocol_metadata_is_framer_message(_ metadata: nw_protocol_metadata_t) -> Bool

nw_protocol_metadata_is_ip

nw_protocol_metadata_is_ip(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): boolean

func nw_protocol_metadata_is_ip(_ metadata: nw_protocol_metadata_t) -> Bool

nw_protocol_metadata_is_quic

nw_protocol_metadata_is_quic(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): boolean

func nw_protocol_metadata_is_quic(_ metadata: nw_protocol_metadata_t) -> Bool

nw_protocol_metadata_is_tcp

nw_protocol_metadata_is_tcp(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): boolean

func nw_protocol_metadata_is_tcp(_ metadata: nw_protocol_metadata_t) -> Bool

nw_protocol_metadata_is_tls

nw_protocol_metadata_is_tls(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): boolean

func nw_protocol_metadata_is_tls(_ metadata: nw_protocol_metadata_t) -> Bool

nw_protocol_metadata_is_udp

nw_protocol_metadata_is_udp(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): boolean

func nw_protocol_metadata_is_udp(_ metadata: nw_protocol_metadata_t) -> Bool

nw_protocol_metadata_is_ws

nw_protocol_metadata_is_ws(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): boolean

func nw_protocol_metadata_is_ws(_ metadata: nw_protocol_metadata_t) -> Bool

nw_protocol_options_copy_definition

nw_protocol_options_copy_definition(options: Implements<OS_nw_protocol_options> | SDKHandle): SDKHandle

func nw_protocol_options_copy_definition(_ options: nw_protocol_options_t) -> nw_protocol_definition_t

nw_protocol_options_is_quic

nw_protocol_options_is_quic(options: Implements<OS_nw_protocol_options> | SDKHandle): boolean

func nw_protocol_options_is_quic(_ options: nw_protocol_options_t) -> Bool

nw_protocol_stack_clear_application_protocols

nw_protocol_stack_clear_application_protocols(stack: Implements<OS_nw_protocol_stack> | SDKHandle): void

func nw_protocol_stack_clear_application_protocols(_ stack: nw_protocol_stack_t)

nw_protocol_stack_copy_internet_protocol

nw_protocol_stack_copy_internet_protocol(stack: Implements<OS_nw_protocol_stack> | SDKHandle): (SDKHandle) | null

func nw_protocol_stack_copy_internet_protocol(_ stack: nw_protocol_stack_t) -> nw_protocol_options_t?

nw_protocol_stack_copy_transport_protocol

nw_protocol_stack_copy_transport_protocol(stack: Implements<OS_nw_protocol_stack> | SDKHandle): (SDKHandle) | null

func nw_protocol_stack_copy_transport_protocol(_ stack: nw_protocol_stack_t) -> nw_protocol_options_t?

nw_protocol_stack_iterate_application_protocols

nw_protocol_stack_iterate_application_protocols(stack: Implements<OS_nw_protocol_stack> | SDKHandle, iterate_block: ((arg0: SDKHandle) => void)): void

func nw_protocol_stack_iterate_application_protocols(_ stack: nw_protocol_stack_t, _ iterate_block: (nw_protocol_options_t) -> Void)

nw_protocol_stack_prepend_application_protocol

nw_protocol_stack_prepend_application_protocol(stack: Implements<OS_nw_protocol_stack> | SDKHandle, protocol: Implements<OS_nw_protocol_options> | SDKHandle): void

func nw_protocol_stack_prepend_application_protocol(_ stack: nw_protocol_stack_t, _ protocol: nw_protocol_options_t)

nw_protocol_stack_set_transport_protocol

nw_protocol_stack_set_transport_protocol(stack: Implements<OS_nw_protocol_stack> | SDKHandle, protocol: Implements<OS_nw_protocol_options> | SDKHandle): void

func nw_protocol_stack_set_transport_protocol(_ stack: nw_protocol_stack_t, _ protocol: nw_protocol_options_t)

nw_proxy_config_add_excluded_domain

nw_proxy_config_add_excluded_domain(config: Implements<OS_nw_proxy_config> | SDKHandle, excluded_domain: SDKHandle): void

func nw_proxy_config_add_excluded_domain(_ config: nw_proxy_config_t, _ excluded_domain: UnsafePointer<CChar>)

nw_proxy_config_add_match_domain

nw_proxy_config_add_match_domain(config: Implements<OS_nw_proxy_config> | SDKHandle, match_domain: SDKHandle): void

func nw_proxy_config_add_match_domain(_ config: nw_proxy_config_t, _ match_domain: UnsafePointer<CChar>)

nw_proxy_config_clear_excluded_domains

nw_proxy_config_clear_excluded_domains(config: Implements<OS_nw_proxy_config> | SDKHandle): void

func nw_proxy_config_clear_excluded_domains(_ config: nw_proxy_config_t)

nw_proxy_config_clear_match_domains

nw_proxy_config_clear_match_domains(config: Implements<OS_nw_proxy_config> | SDKHandle): void

func nw_proxy_config_clear_match_domains(_ config: nw_proxy_config_t)

nw_proxy_config_create_http_connect

nw_proxy_config_create_http_connect(proxy_endpoint: Implements<OS_nw_endpoint> | SDKHandle, proxy_tls_options?: (Implements<OS_nw_protocol_options> | SDKHandle) | null): SDKHandle

func nw_proxy_config_create_http_connect(_ proxy_endpoint: nw_endpoint_t, _ proxy_tls_options: nw_protocol_options_t?) -> nw_proxy_config_t

nw_proxy_config_create_oblivious_http

nw_proxy_config_create_oblivious_http(relay: Implements<OS_nw_relay_hop> | SDKHandle, relay_resource_path: SDKHandle, gateway_key_config: SDKHandle, gateway_key_config_length: number): SDKHandle

func nw_proxy_config_create_oblivious_http(_ relay: nw_relay_hop_t, _ relay_resource_path: UnsafePointer<CChar>, _ gateway_key_config: UnsafePointer<UInt8>, _ gateway_key_config_length: Int) -> nw_proxy_config_t

nw_proxy_config_create_relay

nw_proxy_config_create_relay(first_hop: Implements<OS_nw_relay_hop> | SDKHandle, second_hop?: (Implements<OS_nw_relay_hop> | SDKHandle) | null): SDKHandle

func nw_proxy_config_create_relay(_ first_hop: nw_relay_hop_t, _ second_hop: nw_relay_hop_t?) -> nw_proxy_config_t

nw_proxy_config_create_socksv5

nw_proxy_config_create_socksv5(proxy_endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_proxy_config_create_socksv5(_ proxy_endpoint: nw_endpoint_t) -> nw_proxy_config_t

nw_proxy_config_enumerate_excluded_domains

nw_proxy_config_enumerate_excluded_domains(config: Implements<OS_nw_proxy_config> | SDKHandle, enumerator: ((arg0: SDKHandle) => void)): void

func nw_proxy_config_enumerate_excluded_domains(_ config: nw_proxy_config_t, _ enumerator: (UnsafePointer<CChar>) -> Void)

nw_proxy_config_enumerate_match_domains

nw_proxy_config_enumerate_match_domains(config: Implements<OS_nw_proxy_config> | SDKHandle, enumerator: ((arg0: SDKHandle) => void)): void

func nw_proxy_config_enumerate_match_domains(_ config: nw_proxy_config_t, _ enumerator: (UnsafePointer<CChar>) -> Void)

nw_proxy_config_get_failover_allowed

nw_proxy_config_get_failover_allowed(proxy_config: Implements<OS_nw_proxy_config> | SDKHandle): boolean

func nw_proxy_config_get_failover_allowed(_ proxy_config: nw_proxy_config_t) -> Bool

nw_proxy_config_set_failover_allowed

nw_proxy_config_set_failover_allowed(proxy_config: Implements<OS_nw_proxy_config> | SDKHandle, failover_allowed: boolean): void

func nw_proxy_config_set_failover_allowed(_ proxy_config: nw_proxy_config_t, _ failover_allowed: Bool)

nw_proxy_config_set_username_and_password

nw_proxy_config_set_username_and_password(proxy_config: Implements<OS_nw_proxy_config> | SDKHandle, username: SDKHandle, password?: (SDKHandle) | null): void

func nw_proxy_config_set_username_and_password(_ proxy_config: nw_proxy_config_t, _ username: UnsafePointer<CChar>, _ password: UnsafePointer<CChar>?)

nw_quic_add_tls_application_protocol

nw_quic_add_tls_application_protocol(options: Implements<OS_nw_protocol_options> | SDKHandle, application_protocol: SDKHandle): void

func nw_quic_add_tls_application_protocol(_ options: nw_protocol_options_t, _ application_protocol: UnsafePointer<CChar>)

nw_quic_copy_sec_protocol_metadata

nw_quic_copy_sec_protocol_metadata(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): SDKHandle

func nw_quic_copy_sec_protocol_metadata(_ metadata: nw_protocol_metadata_t) -> sec_protocol_metadata_t

nw_quic_copy_sec_protocol_options

nw_quic_copy_sec_protocol_options(options: Implements<OS_nw_protocol_options> | SDKHandle): SDKHandle

func nw_quic_copy_sec_protocol_options(_ options: nw_protocol_options_t) -> sec_protocol_options_t

nw_quic_create_options

nw_quic_create_options(): SDKHandle

func nw_quic_create_options() -> nw_protocol_options_t

nw_quic_get_application_error

nw_quic_get_application_error(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_application_error(_ metadata: nw_protocol_metadata_t) -> UInt64

nw_quic_get_application_error_reason

nw_quic_get_application_error_reason(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): (SDKHandle) | null

func nw_quic_get_application_error_reason(_ metadata: nw_protocol_metadata_t) -> UnsafePointer<CChar>?

nw_quic_get_idle_timeout

nw_quic_get_idle_timeout(options: Implements<OS_nw_protocol_options> | SDKHandle): number

func nw_quic_get_idle_timeout(_ options: nw_protocol_options_t) -> UInt32

nw_quic_get_initial_max_data

nw_quic_get_initial_max_data(options: Implements<OS_nw_protocol_options> | SDKHandle): number

func nw_quic_get_initial_max_data(_ options: nw_protocol_options_t) -> UInt64

nw_quic_get_initial_max_stream_data_bidirectional_local

nw_quic_get_initial_max_stream_data_bidirectional_local(options: Implements<OS_nw_protocol_options> | SDKHandle): number

func nw_quic_get_initial_max_stream_data_bidirectional_local(_ options: nw_protocol_options_t) -> UInt64

nw_quic_get_initial_max_stream_data_bidirectional_remote

nw_quic_get_initial_max_stream_data_bidirectional_remote(options: Implements<OS_nw_protocol_options> | SDKHandle): number

func nw_quic_get_initial_max_stream_data_bidirectional_remote(_ options: nw_protocol_options_t) -> UInt64

nw_quic_get_initial_max_stream_data_unidirectional

nw_quic_get_initial_max_stream_data_unidirectional(options: Implements<OS_nw_protocol_options> | SDKHandle): number

func nw_quic_get_initial_max_stream_data_unidirectional(_ options: nw_protocol_options_t) -> UInt64

nw_quic_get_initial_max_streams_bidirectional

nw_quic_get_initial_max_streams_bidirectional(options: Implements<OS_nw_protocol_options> | SDKHandle): number

func nw_quic_get_initial_max_streams_bidirectional(_ options: nw_protocol_options_t) -> UInt64

nw_quic_get_initial_max_streams_unidirectional

nw_quic_get_initial_max_streams_unidirectional(options: Implements<OS_nw_protocol_options> | SDKHandle): number

func nw_quic_get_initial_max_streams_unidirectional(_ options: nw_protocol_options_t) -> UInt64

nw_quic_get_keepalive_interval

nw_quic_get_keepalive_interval(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_keepalive_interval(_ metadata: nw_protocol_metadata_t) -> UInt16

nw_quic_get_local_max_streams_bidirectional

nw_quic_get_local_max_streams_bidirectional(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_local_max_streams_bidirectional(_ metadata: nw_protocol_metadata_t) -> UInt64

nw_quic_get_local_max_streams_unidirectional

nw_quic_get_local_max_streams_unidirectional(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_local_max_streams_unidirectional(_ metadata: nw_protocol_metadata_t) -> UInt64

nw_quic_get_max_datagram_frame_size

nw_quic_get_max_datagram_frame_size(options: Implements<OS_nw_protocol_options> | SDKHandle): number

func nw_quic_get_max_datagram_frame_size(_ options: nw_protocol_options_t) -> UInt16

nw_quic_get_max_udp_payload_size

nw_quic_get_max_udp_payload_size(options: Implements<OS_nw_protocol_options> | SDKHandle): number

func nw_quic_get_max_udp_payload_size(_ options: nw_protocol_options_t) -> UInt16

nw_quic_get_remote_idle_timeout

nw_quic_get_remote_idle_timeout(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_remote_idle_timeout(_ metadata: nw_protocol_metadata_t) -> UInt64

nw_quic_get_remote_max_streams_bidirectional

nw_quic_get_remote_max_streams_bidirectional(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_remote_max_streams_bidirectional(_ metadata: nw_protocol_metadata_t) -> UInt64

nw_quic_get_remote_max_streams_unidirectional

nw_quic_get_remote_max_streams_unidirectional(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_remote_max_streams_unidirectional(_ metadata: nw_protocol_metadata_t) -> UInt64

nw_quic_get_stream_application_error

nw_quic_get_stream_application_error(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_stream_application_error(_ metadata: nw_protocol_metadata_t) -> UInt64

nw_quic_get_stream_id

nw_quic_get_stream_id(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_stream_id(_ metadata: nw_protocol_metadata_t) -> UInt64

nw_quic_get_stream_is_datagram

nw_quic_get_stream_is_datagram(options: Implements<OS_nw_protocol_options> | SDKHandle): boolean

func nw_quic_get_stream_is_datagram(_ options: nw_protocol_options_t) -> Bool

nw_quic_get_stream_is_unidirectional

nw_quic_get_stream_is_unidirectional(options: Implements<OS_nw_protocol_options> | SDKHandle): boolean

func nw_quic_get_stream_is_unidirectional(_ options: nw_protocol_options_t) -> Bool

nw_quic_get_stream_type

nw_quic_get_stream_type(stream_metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_stream_type(_ stream_metadata: nw_protocol_metadata_t) -> UInt8

nw_quic_get_stream_usable_datagram_frame_size

nw_quic_get_stream_usable_datagram_frame_size(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_quic_get_stream_usable_datagram_frame_size(_ metadata: nw_protocol_metadata_t) -> UInt16

nw_quic_set_application_error

nw_quic_set_application_error(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, application_error: number, reason?: (SDKHandle) | null): void

func nw_quic_set_application_error(_ metadata: nw_protocol_metadata_t, _ application_error: UInt64, _ reason: UnsafePointer<CChar>?)

nw_quic_set_idle_timeout

nw_quic_set_idle_timeout(options: Implements<OS_nw_protocol_options> | SDKHandle, idle_timeout: number): void

func nw_quic_set_idle_timeout(_ options: nw_protocol_options_t, _ idle_timeout: UInt32)

nw_quic_set_initial_max_data

nw_quic_set_initial_max_data(options: Implements<OS_nw_protocol_options> | SDKHandle, initial_max_data: number): void

func nw_quic_set_initial_max_data(_ options: nw_protocol_options_t, _ initial_max_data: UInt64)

nw_quic_set_initial_max_stream_data_bidirectional_local

nw_quic_set_initial_max_stream_data_bidirectional_local(options: Implements<OS_nw_protocol_options> | SDKHandle, initial_max_stream_data_bidirectional_local: number): void

func nw_quic_set_initial_max_stream_data_bidirectional_local(_ options: nw_protocol_options_t, _ initial_max_stream_data_bidirectional_local: UInt64)

nw_quic_set_initial_max_stream_data_bidirectional_remote

nw_quic_set_initial_max_stream_data_bidirectional_remote(options: Implements<OS_nw_protocol_options> | SDKHandle, initial_max_stream_data_bidirectional_remote: number): void

func nw_quic_set_initial_max_stream_data_bidirectional_remote(_ options: nw_protocol_options_t, _ initial_max_stream_data_bidirectional_remote: UInt64)

nw_quic_set_initial_max_stream_data_unidirectional

nw_quic_set_initial_max_stream_data_unidirectional(options: Implements<OS_nw_protocol_options> | SDKHandle, initial_max_stream_data_unidirectional: number): void

func nw_quic_set_initial_max_stream_data_unidirectional(_ options: nw_protocol_options_t, _ initial_max_stream_data_unidirectional: UInt64)

nw_quic_set_initial_max_streams_bidirectional

nw_quic_set_initial_max_streams_bidirectional(options: Implements<OS_nw_protocol_options> | SDKHandle, initial_max_streams_bidirectional: number): void

func nw_quic_set_initial_max_streams_bidirectional(_ options: nw_protocol_options_t, _ initial_max_streams_bidirectional: UInt64)

nw_quic_set_initial_max_streams_unidirectional

nw_quic_set_initial_max_streams_unidirectional(options: Implements<OS_nw_protocol_options> | SDKHandle, initial_max_streams_unidirectional: number): void

func nw_quic_set_initial_max_streams_unidirectional(_ options: nw_protocol_options_t, _ initial_max_streams_unidirectional: UInt64)

nw_quic_set_keepalive_interval

nw_quic_set_keepalive_interval(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, keepalive_interval: number): void

func nw_quic_set_keepalive_interval(_ metadata: nw_protocol_metadata_t, _ keepalive_interval: UInt16)

nw_quic_set_local_max_streams_bidirectional

nw_quic_set_local_max_streams_bidirectional(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, max_streams_bidirectional: number): void

func nw_quic_set_local_max_streams_bidirectional(_ metadata: nw_protocol_metadata_t, _ max_streams_bidirectional: UInt64)

nw_quic_set_local_max_streams_unidirectional

nw_quic_set_local_max_streams_unidirectional(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, max_streams_unidirectional: number): void

func nw_quic_set_local_max_streams_unidirectional(_ metadata: nw_protocol_metadata_t, _ max_streams_unidirectional: UInt64)

nw_quic_set_max_datagram_frame_size

nw_quic_set_max_datagram_frame_size(options: Implements<OS_nw_protocol_options> | SDKHandle, max_datagram_frame_size: number): void

func nw_quic_set_max_datagram_frame_size(_ options: nw_protocol_options_t, _ max_datagram_frame_size: UInt16)

nw_quic_set_max_udp_payload_size

nw_quic_set_max_udp_payload_size(options: Implements<OS_nw_protocol_options> | SDKHandle, max_udp_payload_size: number): void

func nw_quic_set_max_udp_payload_size(_ options: nw_protocol_options_t, _ max_udp_payload_size: UInt16)

nw_quic_set_stream_application_error

nw_quic_set_stream_application_error(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, application_error: number): void

func nw_quic_set_stream_application_error(_ metadata: nw_protocol_metadata_t, _ application_error: UInt64)

nw_quic_set_stream_is_datagram

nw_quic_set_stream_is_datagram(options: Implements<OS_nw_protocol_options> | SDKHandle, is_datagram: boolean): void

func nw_quic_set_stream_is_datagram(_ options: nw_protocol_options_t, _ is_datagram: Bool)

nw_quic_set_stream_is_unidirectional

nw_quic_set_stream_is_unidirectional(options: Implements<OS_nw_protocol_options> | SDKHandle, is_unidirectional: boolean): void

func nw_quic_set_stream_is_unidirectional(_ options: nw_protocol_options_t, _ is_unidirectional: Bool)

nw_relay_hop_add_additional_http_header_field

nw_relay_hop_add_additional_http_header_field(relay_hop: Implements<OS_nw_relay_hop> | SDKHandle, field_name: SDKHandle, field_value: SDKHandle): void

func nw_relay_hop_add_additional_http_header_field(_ relay_hop: nw_relay_hop_t, _ field_name: UnsafePointer<CChar>, _ field_value: UnsafePointer<CChar>)

nw_relay_hop_create

nw_relay_hop_create(http3_relay_endpoint?: (Implements<OS_nw_endpoint> | SDKHandle) | null, http2_relay_endpoint?: (Implements<OS_nw_endpoint> | SDKHandle) | null, relay_tls_options?: (Implements<OS_nw_protocol_options> | SDKHandle) | null): SDKHandle

func nw_relay_hop_create(_ http3_relay_endpoint: nw_endpoint_t?, _ http2_relay_endpoint: nw_endpoint_t?, _ relay_tls_options: nw_protocol_options_t?) -> nw_relay_hop_t

nw_resolution_report_copy_preferred_endpoint

nw_resolution_report_copy_preferred_endpoint(resolution_report: Implements<OS_nw_resolution_report> | SDKHandle): SDKHandle

func nw_resolution_report_copy_preferred_endpoint(_ resolution_report: nw_resolution_report_t) -> nw_endpoint_t

nw_resolution_report_copy_successful_endpoint

nw_resolution_report_copy_successful_endpoint(resolution_report: Implements<OS_nw_resolution_report> | SDKHandle): SDKHandle

func nw_resolution_report_copy_successful_endpoint(_ resolution_report: nw_resolution_report_t) -> nw_endpoint_t

nw_resolution_report_get_endpoint_count

nw_resolution_report_get_endpoint_count(resolution_report: Implements<OS_nw_resolution_report> | SDKHandle): number

func nw_resolution_report_get_endpoint_count(_ resolution_report: nw_resolution_report_t) -> UInt32

nw_resolution_report_get_milliseconds

nw_resolution_report_get_milliseconds(resolution_report: Implements<OS_nw_resolution_report> | SDKHandle): number

func nw_resolution_report_get_milliseconds(_ resolution_report: nw_resolution_report_t) -> UInt64

nw_resolution_report_get_protocol

nw_resolution_report_get_protocol(resolution_report: Implements<OS_nw_resolution_report> | SDKHandle): nw_report_resolution_protocol_t

func nw_resolution_report_get_protocol(_ resolution_report: nw_resolution_report_t) -> nw_report_resolution_protocol_t

nw_resolution_report_get_source

nw_resolution_report_get_source(resolution_report: Implements<OS_nw_resolution_report> | SDKHandle): nw_report_resolution_source_t

func nw_resolution_report_get_source(_ resolution_report: nw_resolution_report_t) -> nw_report_resolution_source_t

nw_resolver_config_add_server_address

nw_resolver_config_add_server_address(config: Implements<OS_nw_resolver_config> | SDKHandle, server_address: Implements<OS_nw_endpoint> | SDKHandle): void

func nw_resolver_config_add_server_address(_ config: nw_resolver_config_t, _ server_address: nw_endpoint_t)

nw_resolver_config_create_https

nw_resolver_config_create_https(url_endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_resolver_config_create_https(_ url_endpoint: nw_endpoint_t) -> nw_resolver_config_t

nw_resolver_config_create_tls

nw_resolver_config_create_tls(server_endpoint: Implements<OS_nw_endpoint> | SDKHandle): SDKHandle

func nw_resolver_config_create_tls(_ server_endpoint: nw_endpoint_t) -> nw_resolver_config_t

nw_tcp_create_options

nw_tcp_create_options(): SDKHandle

func nw_tcp_create_options() -> nw_protocol_options_t

nw_tcp_get_available_receive_buffer

nw_tcp_get_available_receive_buffer(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_tcp_get_available_receive_buffer(_ metadata: nw_protocol_metadata_t) -> UInt32

nw_tcp_get_available_send_buffer

nw_tcp_get_available_send_buffer(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): number

func nw_tcp_get_available_send_buffer(_ metadata: nw_protocol_metadata_t) -> UInt32

nw_tcp_options_set_connection_timeout

nw_tcp_options_set_connection_timeout(options: Implements<OS_nw_protocol_options> | SDKHandle, connection_timeout: number): void

func nw_tcp_options_set_connection_timeout(_ options: nw_protocol_options_t, _ connection_timeout: UInt32)

nw_tcp_options_set_disable_ack_stretching

nw_tcp_options_set_disable_ack_stretching(options: Implements<OS_nw_protocol_options> | SDKHandle, disable_ack_stretching: boolean): void

func nw_tcp_options_set_disable_ack_stretching(_ options: nw_protocol_options_t, _ disable_ack_stretching: Bool)

nw_tcp_options_set_disable_ecn

nw_tcp_options_set_disable_ecn(options: Implements<OS_nw_protocol_options> | SDKHandle, disable_ecn: boolean): void

func nw_tcp_options_set_disable_ecn(_ options: nw_protocol_options_t, _ disable_ecn: Bool)

nw_tcp_options_set_enable_fast_open

nw_tcp_options_set_enable_fast_open(options: Implements<OS_nw_protocol_options> | SDKHandle, enable_fast_open: boolean): void

func nw_tcp_options_set_enable_fast_open(_ options: nw_protocol_options_t, _ enable_fast_open: Bool)

nw_tcp_options_set_enable_keepalive

nw_tcp_options_set_enable_keepalive(options: Implements<OS_nw_protocol_options> | SDKHandle, enable_keepalive: boolean): void

func nw_tcp_options_set_enable_keepalive(_ options: nw_protocol_options_t, _ enable_keepalive: Bool)

nw_tcp_options_set_keepalive_count

nw_tcp_options_set_keepalive_count(options: Implements<OS_nw_protocol_options> | SDKHandle, keepalive_count: number): void

func nw_tcp_options_set_keepalive_count(_ options: nw_protocol_options_t, _ keepalive_count: UInt32)

nw_tcp_options_set_keepalive_idle_time

nw_tcp_options_set_keepalive_idle_time(options: Implements<OS_nw_protocol_options> | SDKHandle, keepalive_idle_time: number): void

func nw_tcp_options_set_keepalive_idle_time(_ options: nw_protocol_options_t, _ keepalive_idle_time: UInt32)

nw_tcp_options_set_keepalive_interval

nw_tcp_options_set_keepalive_interval(options: Implements<OS_nw_protocol_options> | SDKHandle, keepalive_interval: number): void

func nw_tcp_options_set_keepalive_interval(_ options: nw_protocol_options_t, _ keepalive_interval: UInt32)

nw_tcp_options_set_maximum_segment_size

nw_tcp_options_set_maximum_segment_size(options: Implements<OS_nw_protocol_options> | SDKHandle, maximum_segment_size: number): void

func nw_tcp_options_set_maximum_segment_size(_ options: nw_protocol_options_t, _ maximum_segment_size: UInt32)

nw_tcp_options_set_multipath_force_version

nw_tcp_options_set_multipath_force_version(options: Implements<OS_nw_protocol_options> | SDKHandle, multipath_force_version: nw_multipath_version_t): void

func nw_tcp_options_set_multipath_force_version(_ options: nw_protocol_options_t, _ multipath_force_version: nw_multipath_version_t)

nw_tcp_options_set_no_delay

nw_tcp_options_set_no_delay(options: Implements<OS_nw_protocol_options> | SDKHandle, no_delay: boolean): void

func nw_tcp_options_set_no_delay(_ options: nw_protocol_options_t, _ no_delay: Bool)

nw_tcp_options_set_no_options

nw_tcp_options_set_no_options(options: Implements<OS_nw_protocol_options> | SDKHandle, no_options: boolean): void

func nw_tcp_options_set_no_options(_ options: nw_protocol_options_t, _ no_options: Bool)

nw_tcp_options_set_no_push

nw_tcp_options_set_no_push(options: Implements<OS_nw_protocol_options> | SDKHandle, no_push: boolean): void

func nw_tcp_options_set_no_push(_ options: nw_protocol_options_t, _ no_push: Bool)

nw_tcp_options_set_persist_timeout

nw_tcp_options_set_persist_timeout(options: Implements<OS_nw_protocol_options> | SDKHandle, persist_timeout: number): void

func nw_tcp_options_set_persist_timeout(_ options: nw_protocol_options_t, _ persist_timeout: UInt32)

nw_tcp_options_set_retransmit_connection_drop_time

nw_tcp_options_set_retransmit_connection_drop_time(options: Implements<OS_nw_protocol_options> | SDKHandle, retransmit_connection_drop_time: number): void

func nw_tcp_options_set_retransmit_connection_drop_time(_ options: nw_protocol_options_t, _ retransmit_connection_drop_time: UInt32)

nw_tcp_options_set_retransmit_fin_drop

nw_tcp_options_set_retransmit_fin_drop(options: Implements<OS_nw_protocol_options> | SDKHandle, retransmit_fin_drop: boolean): void

func nw_tcp_options_set_retransmit_fin_drop(_ options: nw_protocol_options_t, _ retransmit_fin_drop: Bool)

nw_tcp_set_max_pacing_rate

nw_tcp_set_max_pacing_rate(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, max_pacing_rate: number): number

func nw_tcp_set_max_pacing_rate(_ metadata: nw_protocol_metadata_t, _ max_pacing_rate: UInt64) -> Int32

nw_tls_copy_sec_protocol_metadata

nw_tls_copy_sec_protocol_metadata(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): SDKHandle

func nw_tls_copy_sec_protocol_metadata(_ metadata: nw_protocol_metadata_t) -> sec_protocol_metadata_t

nw_tls_copy_sec_protocol_options

nw_tls_copy_sec_protocol_options(options: Implements<OS_nw_protocol_options> | SDKHandle): SDKHandle

func nw_tls_copy_sec_protocol_options(_ options: nw_protocol_options_t) -> sec_protocol_options_t

nw_tls_create_options

nw_tls_create_options(): SDKHandle

func nw_tls_create_options() -> nw_protocol_options_t

nw_txt_record_copy

nw_txt_record_copy(txt_record?: (Implements<OS_nw_txt_record> | SDKHandle) | null): (SDKHandle) | null

func nw_txt_record_copy(_ txt_record: nw_txt_record_t?) -> nw_txt_record_t?

nw_txt_record_create_dictionary

nw_txt_record_create_dictionary(): SDKHandle

func nw_txt_record_create_dictionary() -> nw_txt_record_t

nw_txt_record_create_with_bytes

nw_txt_record_create_with_bytes(txt_bytes: SDKHandle, txt_len: number): SDKHandle

func nw_txt_record_create_with_bytes(_ txt_bytes: UnsafePointer<UInt8>, _ txt_len: Int) -> nw_txt_record_t

nw_txt_record_find_key

nw_txt_record_find_key(txt_record: Implements<OS_nw_txt_record> | SDKHandle, key: SDKHandle): nw_txt_record_find_key_t

func nw_txt_record_find_key(_ txt_record: nw_txt_record_t, _ key: UnsafePointer<CChar>) -> nw_txt_record_find_key_t

nw_txt_record_get_key_count

nw_txt_record_get_key_count(txt_record?: (Implements<OS_nw_txt_record> | SDKHandle) | null): number

func nw_txt_record_get_key_count(_ txt_record: nw_txt_record_t?) -> Int

nw_txt_record_is_dictionary

nw_txt_record_is_dictionary(txt_record: Implements<OS_nw_txt_record> | SDKHandle): boolean

func nw_txt_record_is_dictionary(_ txt_record: nw_txt_record_t) -> Bool

nw_txt_record_is_equal

nw_txt_record_is_equal(left?: (Implements<OS_nw_txt_record> | SDKHandle) | null, right?: (Implements<OS_nw_txt_record> | SDKHandle) | null): boolean

func nw_txt_record_is_equal(_ left: nw_txt_record_t?, _ right: nw_txt_record_t?) -> Bool

nw_txt_record_remove_key

nw_txt_record_remove_key(txt_record: Implements<OS_nw_txt_record> | SDKHandle, key: SDKHandle): boolean

func nw_txt_record_remove_key(_ txt_record: nw_txt_record_t, _ key: UnsafePointer<CChar>) -> Bool

nw_txt_record_set_key

nw_txt_record_set_key(txt_record: Implements<OS_nw_txt_record> | SDKHandle, key: SDKHandle, value: (SDKHandle) | null, value_len: number): boolean

func nw_txt_record_set_key(_ txt_record: nw_txt_record_t, _ key: UnsafePointer<CChar>, _ value: UnsafePointer<UInt8>?, _ value_len: Int) -> Bool

nw_udp_create_metadata

nw_udp_create_metadata(): SDKHandle

func nw_udp_create_metadata() -> nw_protocol_metadata_t

nw_udp_create_options

nw_udp_create_options(): SDKHandle

func nw_udp_create_options() -> nw_protocol_options_t

nw_udp_options_set_prefer_no_checksum

nw_udp_options_set_prefer_no_checksum(options: Implements<OS_nw_protocol_options> | SDKHandle, prefer_no_checksum: boolean): void

func nw_udp_options_set_prefer_no_checksum(_ options: nw_protocol_options_t, _ prefer_no_checksum: Bool)

nw_ws_create_metadata

nw_ws_create_metadata(opcode: nw_ws_opcode_t): SDKHandle

func nw_ws_create_metadata(_ opcode: nw_ws_opcode_t) -> nw_protocol_metadata_t

nw_ws_create_options

nw_ws_create_options(version: nw_ws_version_t): SDKHandle

func nw_ws_create_options(_ version: nw_ws_version_t) -> nw_protocol_options_t

nw_ws_metadata_copy_server_response

nw_ws_metadata_copy_server_response(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): SDKHandle

func nw_ws_metadata_copy_server_response(_ metadata: nw_protocol_metadata_t) -> nw_ws_response_t

nw_ws_metadata_get_close_code

nw_ws_metadata_get_close_code(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): nw_ws_close_code_t

func nw_ws_metadata_get_close_code(_ metadata: nw_protocol_metadata_t) -> nw_ws_close_code_t

nw_ws_metadata_get_opcode

nw_ws_metadata_get_opcode(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle): nw_ws_opcode_t

func nw_ws_metadata_get_opcode(_ metadata: nw_protocol_metadata_t) -> nw_ws_opcode_t

nw_ws_metadata_set_close_code

nw_ws_metadata_set_close_code(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, close_code: nw_ws_close_code_t): void

func nw_ws_metadata_set_close_code(_ metadata: nw_protocol_metadata_t, _ close_code: nw_ws_close_code_t)

nw_ws_metadata_set_pong_handler

nw_ws_metadata_set_pong_handler(metadata: Implements<OS_nw_protocol_metadata> | SDKHandle, client_queue: _Dispatch_DispatchQueue, pong_handler: ((arg0: (SDKHandle) | null) => void)): void

func nw_ws_metadata_set_pong_handler(_ metadata: nw_protocol_metadata_t, _ client_queue: dispatch_queue_t, _ pong_handler: @escaping nw_ws_pong_handler_t)

nw_ws_options_add_additional_header

nw_ws_options_add_additional_header(options: Implements<OS_nw_protocol_options> | SDKHandle, name: SDKHandle, value: SDKHandle): void

func nw_ws_options_add_additional_header(_ options: nw_protocol_options_t, _ name: UnsafePointer<CChar>, _ value: UnsafePointer<CChar>)

nw_ws_options_add_subprotocol

nw_ws_options_add_subprotocol(options: Implements<OS_nw_protocol_options> | SDKHandle, subprotocol: SDKHandle): void

func nw_ws_options_add_subprotocol(_ options: nw_protocol_options_t, _ subprotocol: UnsafePointer<CChar>)

nw_ws_options_set_auto_reply_ping

nw_ws_options_set_auto_reply_ping(options: Implements<OS_nw_protocol_options> | SDKHandle, auto_reply_ping: boolean): void

func nw_ws_options_set_auto_reply_ping(_ options: nw_protocol_options_t, _ auto_reply_ping: Bool)

nw_ws_options_set_maximum_message_size

nw_ws_options_set_maximum_message_size(options: Implements<OS_nw_protocol_options> | SDKHandle, maximum_message_size: number): void

func nw_ws_options_set_maximum_message_size(_ options: nw_protocol_options_t, _ maximum_message_size: Int)

nw_ws_options_set_skip_handshake

nw_ws_options_set_skip_handshake(options: Implements<OS_nw_protocol_options> | SDKHandle, skip_handshake: boolean): void

func nw_ws_options_set_skip_handshake(_ options: nw_protocol_options_t, _ skip_handshake: Bool)

nw_ws_response_add_additional_header

nw_ws_response_add_additional_header(response: Implements<OS_nw_ws_response> | SDKHandle, name: SDKHandle, value: SDKHandle): void

func nw_ws_response_add_additional_header(_ response: nw_ws_response_t, _ name: UnsafePointer<CChar>, _ value: UnsafePointer<CChar>)

nw_ws_response_create

nw_ws_response_create(status: nw_ws_response_status_t, selected_subprotocol?: (SDKHandle) | null): SDKHandle

func nw_ws_response_create(_ status: nw_ws_response_status_t, _ selected_subprotocol: UnsafePointer<CChar>?) -> nw_ws_response_t

nw_ws_response_get_selected_subprotocol

nw_ws_response_get_selected_subprotocol(response: Implements<OS_nw_ws_response> | SDKHandle): (SDKHandle) | null

func nw_ws_response_get_selected_subprotocol(_ response: nw_ws_response_t) -> UnsafePointer<CChar>?

nw_ws_response_get_status

nw_ws_response_get_status(response?: (Implements<OS_nw_ws_response> | SDKHandle) | null): nw_ws_response_status_t

func nw_ws_response_get_status(_ response: nw_ws_response_t?) -> nw_ws_response_status_t

kNWErrorDomainDNS

const kNWErrorDomainDNS: _CoreFoundation_CFString

let kNWErrorDomainDNS: CFString

kNWErrorDomainPOSIX

const kNWErrorDomainPOSIX: _CoreFoundation_CFString

let kNWErrorDomainPOSIX: CFString

kNWErrorDomainTLS

const kNWErrorDomainTLS: _CoreFoundation_CFString

let kNWErrorDomainTLS: CFString

kNWErrorDomainWiFiAware

const kNWErrorDomainWiFiAware: _CoreFoundation_CFString

let kNWErrorDomainWiFiAware: CFString

NW_FRAMER_CREATE_FLAGS_DEFAULT

const NW_FRAMER_CREATE_FLAGS_DEFAULT: number

var NW_FRAMER_CREATE_FLAGS_DEFAULT: Int32 { get }

NW_FRAMER_WAKEUP_TIME_FOREVER

const NW_FRAMER_WAKEUP_TIME_FOREVER: number

var NW_FRAMER_WAKEUP_TIME_FOREVER: UInt64 { get }

NW_LISTENER_INFINITE_CONNECTION_LIMIT

const NW_LISTENER_INFINITE_CONNECTION_LIMIT: number

var NW_LISTENER_INFINITE_CONNECTION_LIMIT: UInt32 { get }

NW_QUIC_CONNECTION_DEFAULT_KEEPALIVE

const NW_QUIC_CONNECTION_DEFAULT_KEEPALIVE: number

var NW_QUIC_CONNECTION_DEFAULT_KEEPALIVE: Int32 { get }

withNetworkConnection

withNetworkConnection(endpoint: NWEndpoint, builder: NWParametersBuilder<QUIC, unknown>, handler: ((arg0: NetworkConnection<QUIC>) => Promise<void>)): Promise<void>

nonisolated(nonsending) func withNetworkConnection<ApplicationProtocol>(to endpoint: NWEndpoint, using builder: NWParametersBuilder<ApplicationProtocol>, _ handler: (NetworkConnection<ApplicationProtocol>) async throws -> Void) async throws where ApplicationProtocol : MultiplexProtocol

onPathUpdate

onPathUpdate(handler: ((arg0: NetworkConnection<QUIC>, arg1: NWPath) => void)): NetworkConnection<QUIC>

@discardableResult final func onPathUpdate(_ handler: @escaping @isolated(any) @Sendable (NetworkConnection<ApplicationProtocol>, NWPath) -> Void) -> Self

Set a closure to be called when the connection's path has changed, which may be called multiple times until the connection is cancelled. This closure will inherit the isolation domain of the caller.

onViabilityUpdate

onViabilityUpdate(handler: ((arg0: NetworkConnection<QUIC>, arg1: boolean) => void)): NetworkConnection<QUIC>

@discardableResult final func onViabilityUpdate(_ handler: @escaping @isolated(any) @Sendable (NetworkConnection<ApplicationProtocol>, Bool) -> Void) -> Self

Set a closure to be called when the connection's viability changes, which may be called multiple times until the connection is cancelled. Connections that are not currently viable do not have a route, and packets will not be sent or received. There is a possibility that the connection will become viable again when network connectivity changes. This closure will inherit the isolation domain of the caller.

onBetterPathUpdate

onBetterPathUpdate(handler: ((arg0: NetworkConnection<QUIC>, arg1: boolean) => void)): NetworkConnection<QUIC>

@discardableResult final func onBetterPathUpdate(_ handler: @escaping @isolated(any) @Sendable (NetworkConnection<ApplicationProtocol>, Bool) -> Void) -> Self

A better path being available indicates that the system thinks there is a preferred path or interface to use, compared to the one this connection is actively using. As an example, the connection is established over an expensive cellular interface and an unmetered Wi-Fi interface is now available. Set a closure to be called when a better path becomes available or unavailable, which may be called multiple times until the connection is cancelled. When a better path is available, if it is possible to migrate work from this connection to a new connection, create a new connection to the endpoint. Continue doing work on this connection until the new connection is ready. Once ready, transition work to the new connection and cancel this one. This closure will inherit the isolation domain of the caller.

init

static initToUsing(endpoint: NWEndpoint, builder: NWParametersBuilder<QUIC, unknown>): NetworkConnection<QUIC>

convenience init(to endpoint: NWEndpoint, using builder: NWParametersBuilder<ApplicationProtocol>)

init

static initToUsing65965(provider: Implements<Connectable> | SDKHandle, builder: NWParametersBuilder<QUIC, unknown>): NetworkConnection<QUIC>

convenience init(to provider: any Connectable, using builder: NWParametersBuilder<ApplicationProtocol>)

start

start(): NetworkConnection<QUIC>

final func start() -> Self

Initiate some action to open the connection on the network like making a handshake, initiating a multiplexing session, etc. Starts the connection, which will cause the connection to evaluate its path, do resolution, and try to become ready (connected). `NetworkConnection` establishment is asynchronous. `onStateUpdate` will be called when the state changes. If the connection cannot be established, the state will transition to `waiting` with an associated error describing the reason. If an unrecoverable error is encountered, the state will transition to `failed` with an associated error value. If the connection is established, the state will transition to `ready`. Start should only be called once on a connection, and multiple calls to start will be ignored.

openStream

openStream(directionality?: QUICStream_Directionality): Promise<QUIC_Stream<QUICStream>>

final func openStream(directionality: QUICStream.Directionality = .bidirectional) async throws -> QUIC.Stream<QUICStream>

Initiate a new data stream over QUIC. When invoked with no parameters, the default stream type will be bidirectional. Unidirectional streams can be initiated by setting the optional `bidirectional` parameter to false. This call will start the underlying QUIC connection if it has not been started already and will block until the QUIC connection is ready. While streams can be cancelled independently of the underlying connection, if the parent NetworkChannel is cancelled or fails, the streams will as well.

inboundStreams

inboundStreams(handler: ((arg0: QUIC_Stream<QUICStream>) => Promise<void>)): Promise<void>

final func inboundStreams(_ handler: @escaping @isolated(any) @Sendable (QUIC.Stream<QUICStream>) async throws -> Void) async throws

Handle inbound streams and provide a closure on which callback handlers will be executed. When the `NetworkConnection<QUIC>` state moves to `ready`, the internal listener is registered with the system and can receive incoming streams on the multiplexing instance. `inboundStreams` should only be called once on a `NetworkConnection<QUIC>`, and multiple calls to run will throw an exception. If the `NetworkConnection<QUIC>` is not started at the time that `inboundStreams` is invoked, it will be started. The closure inherits the isolation domain of the caller.

negotiatedALPN

get negotiatedALPN(): (string) | null

final var negotiatedALPN: String? { get }

Return the negotiated application protocol used when establishing the connection

applicationError

get applicationError(): NWProtocolQUIC_ApplicationError

final var applicationError: NWProtocolQUIC.ApplicationError { get set }

The QUIC application error code to send for the connection, or received from the peer.

applicationError

set applicationError(value: NWProtocolQUIC_ApplicationError)

final var applicationError: NWProtocolQUIC.ApplicationError { get set }

The QUIC application error code to send for the connection, or received from the peer.

remoteIdleTimeout

get remoteIdleTimeout(): number

final var remoteIdleTimeout: Int { get }

Access the idle_timeout value in milliseconds received from the peer in the transport parameters.

usableDatagramFrameSize

get usableDatagramFrameSize(): number

final var usableDatagramFrameSize: Int { get }

Get the usable size of a datagram frame from a QUIC datagram flow.

securityProtocolMetadata

get securityProtocolMetadata(): SDKHandle

final var securityProtocolMetadata: sec_protocol_metadata_t { get }

Access the sec_protocol_metadata_t for the QUIC Connection. See <Security/SecProtocolMetadata.h> for functions to further access security metadata.

remoteMaxStreamsBidirectional

get remoteMaxStreamsBidirectional(): number

final var remoteMaxStreamsBidirectional: Int { get }

Get the maximum number of bidirectional streams advertised by peer that an application is allowed to create. Note that while attempts to create streams above this limit will be blocked until the server increases the limit, these blocked attempts will cause a STREAMS_BLOCKED frame to be sent to the server. This informs the server that the client has more streams it would like to create. As a result, the caller should attempt to create streams over this limit if it desires more streams.

remoteMaxStreamsUnidirectional

get remoteMaxStreamsUnidirectional(): number

final var remoteMaxStreamsUnidirectional: Int { get }

Get the maximum number of unidirectional streams advertised by peer that an application is allowed to create. Note that while attempts to create streams above this limit will be blocked until the server increases the limit, these blocked attempts will cause a STREAMS_BLOCKED frame to be sent to the server. This informs the server that the client has more streams it would like to create. As a result, the caller should attempt to create streams over this limit if it desires more streams.

datagrams

get datagrams(): Promise<QUIC_Datagrams<QUICDatagram>>

final var datagrams: QUIC.Datagrams<QUICDatagram> { get async throws }

Access connection-wide unreliable datagrams over QUIC. Subsequent accesses to this object will return the same reference. All incoming datagrams for the entire QUIC connection will be received on this `SubConnection` once invoked.

keepalive

get keepalive(): NWProtocolQUIC_Metadata_KeepAliveBehavior

final var keepalive: NWProtocolQUIC.Metadata.KeepAliveBehavior { get set }

Set the QUIC connection keepalive interval.

keepalive

set keepalive(value: NWProtocolQUIC_Metadata_KeepAliveBehavior)

final var keepalive: NWProtocolQUIC.Metadata.KeepAliveBehavior { get set }

Set the QUIC connection keepalive interval.

debugDescription

get debugDescription(): string

final var debugDescription: String { get }

A textual representation of this instance, suitable for debugging. Calling this property directly is discouraged. Instead, convert an instance of any type to a string by using the `String(reflecting:)` initializer. This initializer works with any type, and uses the custom `debugDescription` property for types that conform to `CustomDebugStringConvertible`: struct Point: CustomDebugStringConvertible { let x: Int, y: Int var debugDescription: String { return "(\(x), \(y))" } } let p = Point(x: 21, y: 30) let s = String(reflecting: p) print(s) // Prints "(21, 30)" The conversion of `p` to a string in the assignment to `s` uses the `Point` type's `debugDescription` property.

parameters

get parameters(): NWParameters

var parameters: NWParameters { get }

debugDescription

get debugDescription(): string

var debugDescription: String { get }

Generate a string representation of NetworkChannel suitable for logging

dataTransferReport

dataTransferReport(): Promise<NWConnection_DataTransferReport>

func dataTransferReport() async throws -> NWConnection.DataTransferReport

Start a data transfer report on a connection. The report begins capturing data when the connection moves to the .ready state, or when the report is created (whichever occurs last). This method will start the connection if it isn't already started.

establishmentReport

establishmentReport(): Promise<NWConnection_EstablishmentReport>

func establishmentReport() async throws -> NWConnection.EstablishmentReport

Asynchronously request the establishment report for this connection. If called prior to the connection being in the .ready state, this method will wait until the connection becomes ready and then deliver the report. This method will start the connection if it isn't already started.

maximumDatagramSize

get maximumDatagramSize(): number

var maximumDatagramSize: Int { get }

Retrieve the maximum datagram size that can be sent on the channel. Any datagrams sent should be less than or equal to this size.

id

get id(): string

var id: String { get }

The stable identity of the entity associated with this instance.

state

get state(): NetworkChannel_State<SDKHandle>

var state: NetworkChannel<ApplicationProtocol>.State { get }

Access the current state of the connection

metadata

metadata(definition: NWProtocolDefinition): (NWProtocolMetadata) | null

func metadata(definition: NWProtocolDefinition) -> NWProtocolMetadata?

Access connection-wide protocol metadata on the connection. This allows access to state for protocols like TCP and TLS that have long-term state.

onPathUpdate

onPathUpdate(handler: ((arg0: NetworkChannel<QUICStream>, arg1: NWPath) => void)): NetworkChannel<QUICStream>

@discardableResult func onPathUpdate(_ handler: @escaping @isolated(any) @Sendable (Self, NWPath) -> Void) -> Self

Set a closure to be called when the connection's path has changed, which may be called multiple times until the connection is cancelled. This closure will inherit the isolation domain of the caller.

onViabilityUpdate

onViabilityUpdate(handler: ((arg0: NetworkChannel<QUICStream>, arg1: boolean) => void)): NetworkChannel<QUICStream>

@discardableResult func onViabilityUpdate(_ handler: @escaping @isolated(any) @Sendable (Self, Bool) -> Void) -> Self

Set a closure to be called when the connection's viability changes, which may be called multiple times until the connection is cancelled. Connections that are not currently viable do not have a route, and packets will not be sent or received. There is a possibility that the connection will become viable again when network connectivity changes. This closure will inherit the isolation domain of the caller.

onBetterPathUpdate

onBetterPathUpdate(handler: ((arg0: NetworkChannel<QUICStream>, arg1: boolean) => void)): NetworkChannel<QUICStream>

@discardableResult func onBetterPathUpdate(_ handler: @escaping @isolated(any) @Sendable (Self, Bool) -> Void) -> Self

A better path being available indicates that the system thinks there is a preferred path or interface to use, compared to the one this connection is actively using. As an example, the connection is established over an expensive cellular interface and an unmetered Wi-Fi interface is now available. Set a closure to be called when a better path becomes available or unavailable, which may be called multiple times until the connection is cancelled. When a better path is available, if it is possible to migrate work from this connection to a new connection, create a new connection to the endpoint. Continue doing work on this connection until the new connection is ready. Once ready, transition work to the new connection and cancel this one. This closure will inherit the isolation domain of the caller.

sendIdempotent

sendIdempotentTypeLastMessage(content: ArrayBuffer, type: number, lastMessage?: boolean): void

func sendIdempotent<Content>(_ content: Content, type: Int, lastMessage: Bool = false, @ProtocolMetadataBuilder metadata builder: () -> [NWProtocolMetadata] = {[]}) where Content : DataProtocol

Send idempotent data on a connection. Idempotent content is allowed to be sent before the connection is ready, and may be replayed across parallel connection attempts. This content can be sent as part of fast-open protocols, which allows the data to be sent out sooner than if it were required to wait for connection establishment. > Warning: Idempotent content will be replayed multiple times on the network. It may be subject to weaker security protections than non-idempotent content. Content that needs to be sensitive to sending backpressure should not be considered idempotent. This may be called before the connection is ready, in which case the send will be enqueued until the connection is ready to send. - Parameter content: The data to send. - Parameter type: The message type. - Parameter lastMessage: The last message to send. - Parameter builder: A builder for specifying metadata about the content to send.

send

sendTypeLastMessage(content: ArrayBuffer, type: number, lastMessage?: boolean): Promise<void>

func send<Content>(_ content: Content, type: Int, lastMessage: Bool = false, @ProtocolMetadataBuilder metadata builder: () -> [NWProtocolMetadata] = {[]}) async throws where Content : DataProtocol

Send data on a connection. This may be called before the connection is ready, in which case the send will be enqueued until the connection is ready to send. - Parameter content: The data to send. - Parameter type: The message type. - Parameter lastMessage: The last message to send. - Parameter builder: A builder for specifying metadata about the content to send.

receive

receive(): Promise<"count" | SDKHandle>

func receive() async throws -> ApplicationProtocol.Message<Data>

Receive data from a connection. This may be called before the connection is ready, in which case the receive request will be enqueued until the connection is ready.

sendIdempotent

sendIdempotent(content: string): void

func sendIdempotent(_ content: String, @ProtocolMetadataBuilder metadata builder: () -> [NWProtocolMetadata] = {[]})

Send an idempotent text frame on a WebSocket connection. Idempotent content is allowed to be sent before the connection is ready, and may be replayed across parallel connection attempts. This content can be sent as part of fast-open protocols, which allows the data to be sent out sooner than if it were required to wait for connection establishment. > Warning: Idempotent content will be replayed multiple times on the network. It may be subject to weaker security protections than non-idempotent content. Content that needs to be sensitive to sending backpressure should not be considered idempotent. This may be called before the connection is ready, in which case the send will be enqueued until the connection is ready to send. - Parameter content: A string to send. - Parameter builder: A builder for specifying metadata about the content to send.

sendIdempotent

sendIdempotent70447(content: ArrayBuffer): void

func sendIdempotent<Content>(_ content: Content, @ProtocolMetadataBuilder metadata builder: () -> [NWProtocolMetadata] = {[]}) where Content : DataProtocol

Send an idempotent binary frame on a WebSocket connection. Idempotent content is allowed to be sent before the connection is ready, and may be replayed across parallel connection attempts. This content can be sent as part of fast-open protocols, which allows the data to be sent out sooner than if it were required to wait for connection establishment. > Warning: Idempotent content will be replayed multiple times on the network. It may be subject to weaker security protections than non-idempotent content. Content that needs to be sensitive to sending backpressure should not be considered idempotent. This may be called before the connection is ready, in which case the send will be enqueued until the connection is ready to send. - Parameter content: Idempotent binary data to send. - Parameter builder: A builder for specifying metadata about the content to send.

ping

ping(content?: (ArrayBuffer) | null): Promise<void>

func ping<Content>(_ content: Content? = nil, @ProtocolMetadataBuilder metadata builder: () -> [NWProtocolMetadata] = {[]}) async throws where Content : DataProtocol

Send a ping frame on a connection. This may be called before the connection is ready, in which case the send will be enqueued until the connection is ready to send. - Parameter content: Optional ping data. - Parameter builder: A builder for specifying metadata about the content to send.

pong

pong(content?: (ArrayBuffer) | null): Promise<void>

func pong<Content>(_ content: Content? = nil, @ProtocolMetadataBuilder metadata builder: () -> [NWProtocolMetadata] = {[]}) async throws where Content : DataProtocol

Send a pong frame on a connection. This may be called before the connection is ready, in which case the send will be enqueued until the connection is ready to send. - Parameter content: Optional pong data. - Parameter builder: A builder for specifying metadata about the content to send.

send

send(content: string): Promise<void>

func send(_ content: String, @ProtocolMetadataBuilder metadata builder: () -> [NWProtocolMetadata] = {[]}) async throws

Send a text frame on a WebSocket connection. This may be called before the connection is ready, in which case the send will be enqueued until the connection is ready to send. - Parameter content: A string to send. - Parameter builder: A builder for specifying metadata about the content to send.

send

send1536(content: ArrayBuffer): Promise<void>

func send<Content>(_ content: Content, @ProtocolMetadataBuilder metadata builder: () -> [NWProtocolMetadata] = {[]}) async throws where Content : DataProtocol

Send binary frame on a WebSocket connection. This may be called before the connection is ready, in which case the send will be enqueued until the connection is ready to send. - Parameter content: Data to send. - Parameter builder: A builder for specifying metadata about the content to send.

close

close(code?: NWProtocolWebSocket_CloseCode, reason?: (string) | null): Promise<void>

func close(code: NWProtocolWebSocket.CloseCode = .protocolCode(.normalClosure), reason: String? = nil, @ProtocolMetadataBuilder metadata builder: () -> [NWProtocolMetadata] = {[]}) async throws

Send a WebSocket close frame on a connection. This may be called before the connection is ready, in which case the send will be enqueued until the connection is ready to send. - Parameter code: Optional close code. Defaults to normal closure. - Parameter reason: Optional reason string containing details about the closure. - Parameter builder: A builder for specifying metadata about the content to send.

receive

receive32396(): Promise<"count" | SDKHandle>

func receive() async throws -> ApplicationProtocol.Message<Data>

Receive data from a connection. This may be called before the connection is ready, in which case the receive request will be enqueued until the connection is ready.

debugDescription

get debugDescription(): string

final var debugDescription: String { get }

A textual representation of this instance, suitable for debugging. Calling this property directly is discouraged. Instead, convert an instance of any type to a string by using the `String(reflecting:)` initializer. This initializer works with any type, and uses the custom `debugDescription` property for types that conform to `CustomDebugStringConvertible`: struct Point: CustomDebugStringConvertible { let x: Int, y: Int var debugDescription: String { return "(\(x), \(y))" } } let p = Point(x: 21, y: 30) let s = String(reflecting: p) print(s) // Prints "(21, 30)" The conversion of `p` to a string in the assignment to `s` uses the `Point` type's `debugDescription` property.

newConnectionLimit

get newConnectionLimit(): number

final var newConnectionLimit: Int { get set }

Configure the listener's new connection limit. Use the value NWListener.InfiniteConnectionLimit to disable connection limits. If the value is not NWListener.InfiniteConnectionLimit, the value will be decremented by 1 every time a new connection is received. When the value reaches 0, the new connection handler will no longer be invoked until the the limit is increased.

newConnectionLimit

set newConnectionLimit(value: number)

final var newConnectionLimit: Int { get set }

Configure the listener's new connection limit. Use the value NWListener.InfiniteConnectionLimit to disable connection limits. If the value is not NWListener.InfiniteConnectionLimit, the value will be decremented by 1 every time a new connection is received. When the value reaches 0, the new connection handler will no longer be invoked until the the limit is increased.

port

get port(): (NWEndpoint_Port) | null

final var port: NWEndpoint.Port? { get }

The port that the listener is listening on. Present once the listener becomes ready.

service

get service(): (NWListener_Service) | null

final var service: NWListener.Service? { get set }

An optional service to advertise with the listener. May be modified after the listener becomes ready to update the TXT record or change the advertised service.

service

set service(value: (NWListener_Service) | null)

final var service: NWListener.Service? { get set }

An optional service to advertise with the listener. May be modified after the listener becomes ready to update the TXT record or change the advertised service.

run

run(handler: ((arg0: NetworkConnection<QUIC>) => Promise<void>)): Promise<void>

final func run(_ handler: @escaping @isolated(any) @Sendable (NetworkConnection<ApplicationProtocol>) async throws -> Void) async throws

Run the listener and receive incoming multiplexed connections. Multiplexed connections are connections that contain one or more multiplexing protocols in their protocol stack. They vend connections that represent one logical transport connection, defined by local and remote address, port, and interface or by a protocol-specific connection identifier. Multiple uni- or bi-directional bytestreams and datagram flows are commonly multiplexed over these transport connections and can be obtained from the transport connection directly. When the listener state moves to ready, the listener is registered with the system and can receive incoming connections. `run()` should only be called once on a listener, and multiple calls to `run()` will throw an exception. The closure inherits the isolation domain of the caller. - Parameter handler: A handler to receive incoming multiplexed connections.

parameters

get parameters(): NWParameters

var parameters: NWParameters

The generated NWParameters.

parameters

set parameters(value: NWParameters)

var parameters: NWParameters

The generated NWParameters.

isComplete

get isComplete(): boolean

let isComplete: Bool

lastMessage

get lastMessage(): boolean

let lastMessage: Bool

other

get other(): Array<NWProtocolMetadata>

let other: [NWProtocolMetadata]

options

get options(): NWProtocolFramer_Options

var options: NWProtocolFramer.Options

The framer options to use with this framer. Framer implementations can provide extensions with chainable functions that internally set keys on this options object.

options

set options(value: NWProtocolFramer_Options)

var options: NWProtocolFramer.Options

The framer options to use with this framer. Framer implementations can provide extensions with chainable functions that internally set keys on this options object.

isComplete

get isComplete(): boolean

let isComplete: Bool

lastMessage

get lastMessage(): boolean

let lastMessage: Bool

other

get other(): Array<NWProtocolMetadata>

let other: [NWProtocolMetadata]

framer

get framer(): NWProtocolFramer_Message

let framer: NWProtocolFramer.Message

proxyConfigurations

get proxyConfigurations(): Array<ProxyConfiguration>

var proxyConfigurations: [ProxyConfiguration] { get set }

An array of proxy configurations to apply to all connections that participate in a URLSession.

proxyConfigurations

set proxyConfigurations(value: Array<ProxyConfiguration>)

var proxyConfigurations: [ProxyConfiguration] { get set }

An array of proxy configurations to apply to all connections that participate in a URLSession.