magic_network_monitoring

type ConfigDeleteParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type ConfigDeleteResponseEnvelope struct {
	Errors   []ConfigDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ConfigDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMConfig               `json:"result,required"`
	// Whether the API call was successful
	Success ConfigDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    configDeleteResponseEnvelopeJSON    `json:"-"`
}

type ConfigDeleteResponseEnvelopeErrors struct {
	Code    int64                                  `json:"code,required"`
	Message string                                 `json:"message,required"`
	JSON    configDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

type ConfigDeleteResponseEnvelopeMessages struct {
	Code    int64                                    `json:"code,required"`
	Message string                                   `json:"message,required"`
	JSON    configDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

type ConfigDeleteResponseEnvelopeSuccess bool

type ConfigEditParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type ConfigEditResponseEnvelope struct {
	Errors   []ConfigEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ConfigEditResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMConfig             `json:"result,required"`
	// Whether the API call was successful
	Success ConfigEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    configEditResponseEnvelopeJSON    `json:"-"`
}

type ConfigEditResponseEnvelopeErrors struct {
	Code    int64                                `json:"code,required"`
	Message string                               `json:"message,required"`
	JSON    configEditResponseEnvelopeErrorsJSON `json:"-"`
}

type ConfigEditResponseEnvelopeMessages struct {
	Code    int64                                  `json:"code,required"`
	Message string                                 `json:"message,required"`
	JSON    configEditResponseEnvelopeMessagesJSON `json:"-"`
}

type ConfigEditResponseEnvelopeSuccess bool

type ConfigFullGetParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type ConfigFullGetResponseEnvelope struct {
	Errors   []ConfigFullGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ConfigFullGetResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMConfig                `json:"result,required"`
	// Whether the API call was successful
	Success ConfigFullGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    configFullGetResponseEnvelopeJSON    `json:"-"`
}

type ConfigFullGetResponseEnvelopeErrors struct {
	Code    int64                                   `json:"code,required"`
	Message string                                  `json:"message,required"`
	JSON    configFullGetResponseEnvelopeErrorsJSON `json:"-"`
}

type ConfigFullGetResponseEnvelopeMessages struct {
	Code    int64                                     `json:"code,required"`
	Message string                                    `json:"message,required"`
	JSON    configFullGetResponseEnvelopeMessagesJSON `json:"-"`
}

type ConfigFullGetResponseEnvelopeSuccess bool

type ConfigFullService struct {
	Options []option.RequestOption
}

type ConfigGetParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type ConfigGetResponseEnvelope struct {
	Errors   []ConfigGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ConfigGetResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMConfig            `json:"result,required"`
	// Whether the API call was successful
	Success ConfigGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    configGetResponseEnvelopeJSON    `json:"-"`
}

type ConfigGetResponseEnvelopeErrors struct {
	Code    int64                               `json:"code,required"`
	Message string                              `json:"message,required"`
	JSON    configGetResponseEnvelopeErrorsJSON `json:"-"`
}

type ConfigGetResponseEnvelopeMessages struct {
	Code    int64                                 `json:"code,required"`
	Message string                                `json:"message,required"`
	JSON    configGetResponseEnvelopeMessagesJSON `json:"-"`
}

type ConfigGetResponseEnvelopeSuccess bool

type ConfigNewParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type ConfigNewResponseEnvelope struct {
	Errors   []ConfigNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ConfigNewResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMConfig            `json:"result,required"`
	// Whether the API call was successful
	Success ConfigNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    configNewResponseEnvelopeJSON    `json:"-"`
}

type ConfigNewResponseEnvelopeErrors struct {
	Code    int64                               `json:"code,required"`
	Message string                              `json:"message,required"`
	JSON    configNewResponseEnvelopeErrorsJSON `json:"-"`
}

type ConfigNewResponseEnvelopeMessages struct {
	Code    int64                                 `json:"code,required"`
	Message string                                `json:"message,required"`
	JSON    configNewResponseEnvelopeMessagesJSON `json:"-"`
}

type ConfigNewResponseEnvelopeSuccess bool

type ConfigService struct {
	Options []option.RequestOption
	Full    *ConfigFullService
}

type ConfigUpdateParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type ConfigUpdateResponseEnvelope struct {
	Errors   []ConfigUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ConfigUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMConfig               `json:"result,required"`
	// Whether the API call was successful
	Success ConfigUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    configUpdateResponseEnvelopeJSON    `json:"-"`
}

type ConfigUpdateResponseEnvelopeErrors struct {
	Code    int64                                  `json:"code,required"`
	Message string                                 `json:"message,required"`
	JSON    configUpdateResponseEnvelopeErrorsJSON `json:"-"`
}

type ConfigUpdateResponseEnvelopeMessages struct {
	Code    int64                                    `json:"code,required"`
	Message string                                   `json:"message,required"`
	JSON    configUpdateResponseEnvelopeMessagesJSON `json:"-"`
}

type ConfigUpdateResponseEnvelopeSuccess bool

type Error = apierror.Error

type MagicNetworkMonitoringService struct {
	Options []option.RequestOption
	Configs *ConfigService
	Rules   *RuleService
}

type MagicVisibilityMNMConfig struct {
	// Fallback sampling rate of flow messages being sent in packets per second. This
	// should match the packet sampling rate configured on the router.
	DefaultSampling float64 `json:"default_sampling,required"`
	// The account name.
	Name      string                       `json:"name,required"`
	RouterIPs []string                     `json:"router_ips,required"`
	JSON      magicVisibilityMNMConfigJSON `json:"-"`
}

type MagicVisibilityMNMRule struct {
	// Toggle on if you would like Cloudflare to automatically advertise the IP
	// Prefixes within the rule via Magic Transit when the rule is triggered. Only
	// available for users of Magic Transit.
	AutomaticAdvertisement bool `json:"automatic_advertisement,required,nullable"`
	// The amount of time that the rule threshold must be exceeded to send an alert
	// notification. The final value must be equivalent to one of the following 8
	// values ["1m","5m","10m","15m","20m","30m","45m","60m"]. The format is
	// AhBmCsDmsEusFns where A, B, C, D, E and F durations are optional; however at
	// least one unit must be provided.
	Duration string `json:"duration,required"`
	// The name of the rule. Must be unique. Supports characters A-Z, a-z, 0-9,
	// underscore (\_), dash (-), period (.), and tilde (~). You can’t have a space in
	// the rule name. Max 256 characters.
	Name     string      `json:"name,required"`
	Prefixes []string    `json:"prefixes,required"`
	ID       interface{} `json:"id"`
	// The number of bits per second for the rule. When this value is exceeded for the
	// set duration, an alert notification is sent. Minimum of 1 and no maximum.
	BandwidthThreshold float64 `json:"bandwidth_threshold"`
	// The number of packets per second for the rule. When this value is exceeded for
	// the set duration, an alert notification is sent. Minimum of 1 and no maximum.
	PacketThreshold float64                    `json:"packet_threshold"`
	JSON            magicVisibilityMNMRuleJSON `json:"-"`
}

type MagicVisibilityMNMRuleAdvertisable struct {
	// Toggle on if you would like Cloudflare to automatically advertise the IP
	// Prefixes within the rule via Magic Transit when the rule is triggered. Only
	// available for users of Magic Transit.
	AutomaticAdvertisement bool                                   `json:"automatic_advertisement,required,nullable"`
	JSON                   magicVisibilityMNMRuleAdvertisableJSON `json:"-"`
}

type RuleAdvertisementEditParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type RuleAdvertisementEditResponseEnvelope struct {
	Errors   []RuleAdvertisementEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleAdvertisementEditResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMRuleAdvertisable              `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RuleAdvertisementEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    ruleAdvertisementEditResponseEnvelopeJSON    `json:"-"`
}

type RuleAdvertisementEditResponseEnvelopeErrors struct {
	Code    int64                                           `json:"code,required"`
	Message string                                          `json:"message,required"`
	JSON    ruleAdvertisementEditResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleAdvertisementEditResponseEnvelopeMessages struct {
	Code    int64                                             `json:"code,required"`
	Message string                                            `json:"message,required"`
	JSON    ruleAdvertisementEditResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleAdvertisementEditResponseEnvelopeSuccess bool

type RuleAdvertisementService struct {
	Options []option.RequestOption
}

type RuleDeleteParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type RuleDeleteResponseEnvelope struct {
	Errors   []RuleDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMRule               `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RuleDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    ruleDeleteResponseEnvelopeJSON    `json:"-"`
}

type RuleDeleteResponseEnvelopeErrors struct {
	Code    int64                                `json:"code,required"`
	Message string                               `json:"message,required"`
	JSON    ruleDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleDeleteResponseEnvelopeMessages struct {
	Code    int64                                  `json:"code,required"`
	Message string                                 `json:"message,required"`
	JSON    ruleDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleDeleteResponseEnvelopeSuccess bool

type RuleEditParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type RuleEditResponseEnvelope struct {
	Errors   []RuleEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleEditResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMRule             `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RuleEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    ruleEditResponseEnvelopeJSON    `json:"-"`
}

type RuleEditResponseEnvelopeErrors struct {
	Code    int64                              `json:"code,required"`
	Message string                             `json:"message,required"`
	JSON    ruleEditResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleEditResponseEnvelopeMessages struct {
	Code    int64                                `json:"code,required"`
	Message string                               `json:"message,required"`
	JSON    ruleEditResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleEditResponseEnvelopeSuccess bool

type RuleGetParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type RuleGetResponseEnvelope struct {
	Errors   []RuleGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleGetResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMRule            `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RuleGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    ruleGetResponseEnvelopeJSON    `json:"-"`
}

type RuleGetResponseEnvelopeErrors struct {
	Code    int64                             `json:"code,required"`
	Message string                            `json:"message,required"`
	JSON    ruleGetResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleGetResponseEnvelopeMessages struct {
	Code    int64                               `json:"code,required"`
	Message string                              `json:"message,required"`
	JSON    ruleGetResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleGetResponseEnvelopeSuccess bool

type RuleListParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type RuleListResponseEnvelope struct {
	Errors   []RuleListResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleListResponseEnvelopeMessages `json:"messages,required"`
	Result   []MagicVisibilityMNMRule           `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    RuleListResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo RuleListResponseEnvelopeResultInfo `json:"result_info"`
	JSON       ruleListResponseEnvelopeJSON       `json:"-"`
}

type RuleListResponseEnvelopeErrors struct {
	Code    int64                              `json:"code,required"`
	Message string                             `json:"message,required"`
	JSON    ruleListResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleListResponseEnvelopeMessages struct {
	Code    int64                                `json:"code,required"`
	Message string                               `json:"message,required"`
	JSON    ruleListResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleListResponseEnvelopeResultInfo struct {
	// Total number of results for the requested service
	Count float64 `json:"count"`
	// Current page within paginated list of results
	Page float64 `json:"page"`
	// Number of results per page of results
	PerPage float64 `json:"per_page"`
	// Total results available without any search parameters
	TotalCount float64                                `json:"total_count"`
	JSON       ruleListResponseEnvelopeResultInfoJSON `json:"-"`
}

type RuleListResponseEnvelopeSuccess bool

type RuleNewParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type RuleNewResponseEnvelope struct {
	Errors   []RuleNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleNewResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMRule            `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RuleNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    ruleNewResponseEnvelopeJSON    `json:"-"`
}

type RuleNewResponseEnvelopeErrors struct {
	Code    int64                             `json:"code,required"`
	Message string                            `json:"message,required"`
	JSON    ruleNewResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleNewResponseEnvelopeMessages struct {
	Code    int64                               `json:"code,required"`
	Message string                              `json:"message,required"`
	JSON    ruleNewResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleNewResponseEnvelopeSuccess bool

type RuleService struct {
	Options        []option.RequestOption
	Advertisements *RuleAdvertisementService
}

type RuleUpdateParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type RuleUpdateResponseEnvelope struct {
	Errors   []RuleUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RuleUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   MagicVisibilityMNMRule               `json:"result,required,nullable"`
	// Whether the API call was successful
	Success RuleUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    ruleUpdateResponseEnvelopeJSON    `json:"-"`
}

type RuleUpdateResponseEnvelopeErrors struct {
	Code    int64                                `json:"code,required"`
	Message string                               `json:"message,required"`
	JSON    ruleUpdateResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleUpdateResponseEnvelopeMessages struct {
	Code    int64                                  `json:"code,required"`
	Message string                                 `json:"message,required"`
	JSON    ruleUpdateResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleUpdateResponseEnvelopeSuccess bool