alert_rules.go

// Code generated by internal/cmd/gen; DO NOT EDIT.

package flashduty

import "context"

// AlertRulesService handles the "Monitors/Alert rules" API resource.
type AlertRulesService service

// Get rule audit snapshot.
//
// Return the audit record (including the `content` field, a JSON string of the rule snapshot at that point in time).
//
// API: POST /monit/rule/audit/detail (monit-rule-read-audit-detail).
func (s *AlertRulesService) ReadAuditDetail(ctx context.Context, req *AuditRecordIDRequest) (*AlertRuleAudit, *Response, error) {
	out := new(AlertRuleAudit)
	resp, err := s.client.do(ctx, "/monit/rule/audit/detail", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// List rule change history.
//
// Return the change history (audit records) for an alert rule.
//
// API: POST /monit/rule/audits (monit-rule-read-audits).
func (s *AlertRulesService) ReadAudits(ctx context.Context, req *RuleIDRequest) (*RuleAuditListResponse, *Response, error) {
	out := new(RuleAuditListResponse)
	resp, err := s.client.do(ctx, "/monit/rule/audits", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Get rule counts by channel.
//
// Return an object mapping channel name to the number of rules routing alerts to that channel. If a channel name cannot be resolved, the channel ID (as a string) is used as the key.
//
// API: POST /monit/rule/counter/channel (monit-rule-read-counter-channel).
func (s *AlertRulesService) ReadCounterChannel(ctx context.Context) (*RuleCounterChannelResponse, *Response, error) {
	out := new(RuleCounterChannelResponse)
	resp, err := s.client.do(ctx, "/monit/rule/counter/channel", nil, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Get rule counts by folder node.
//
// Return an object mapping top-level folder name to the total number of rules under that folder and all its descendants.
//
// API: POST /monit/rule/counter/node (monit-rule-read-counter-node).
func (s *AlertRulesService) ReadCounterNode(ctx context.Context) (*RuleCounterNodeResponse, *Response, error) {
	out := new(RuleCounterNodeResponse)
	resp, err := s.client.do(ctx, "/monit/rule/counter/node", nil, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Get rule status counters for top-level folders.
//
// Return trigger status summary for all top-level folder nodes — used for the overview dashboard.
//
// API: POST /monit/rule/counter/status (monit-rule-read-counter-status).
func (s *AlertRulesService) ReadCounterStatus(ctx context.Context) (*RuleStatusResponse, *Response, error) {
	out := new(RuleStatusResponse)
	resp, err := s.client.do(ctx, "/monit/rule/counter/status", nil, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Get rule counter time series.
//
// Return the stored time series of the total rule count across the account — one sample per `clock` timestamp.
//
// API: POST /monit/rule/counter/total (monit-rule-read-counter-total).
func (s *AlertRulesService) ReadCounterTotal(ctx context.Context) (*RuleCounterTotalResponse, *Response, error) {
	out := new(RuleCounterTotalResponse)
	resp, err := s.client.do(ctx, "/monit/rule/counter/total", nil, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// List available datasource types.
//
// Return the list of datasource types (`DSType` records) that the current account can use when authoring alert rules — combines global types and account-scoped types.
//
// API: POST /monit/rule/dstypes (monit-rule-read-dstypes).
func (s *AlertRulesService) ReadDstypes(ctx context.Context) (*RuleDsTypesResponse, *Response, error) {
	out := new(RuleDsTypesResponse)
	resp, err := s.client.do(ctx, "/monit/rule/dstypes", nil, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Export alert rules.
//
// Export the configuration of selected alert rules as a portable JSON array, compatible with `POST /monit/rule/import`.
//
// API: POST /monit/rule/export (monit-rule-read-export).
func (s *AlertRulesService) ReadExport(ctx context.Context, req *RuleIDsRequest) (*AlertRuleExportListResponse, *Response, error) {
	out := new(AlertRuleExportListResponse)
	resp, err := s.client.do(ctx, "/monit/rule/export", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Get alert rule detail.
//
// Return the full configuration of an alert rule by its ID, including rule queries, thresholds, and notification settings.
//
// API: POST /monit/rule/info (monit-rule-read-info).
func (s *AlertRulesService) ReadInfo(ctx context.Context, req *RuleIDRequest) (*AlertRuleInfoResponse, *Response, error) {
	out := new(AlertRuleInfoResponse)
	resp, err := s.client.do(ctx, "/monit/rule/info", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// List alert rules.
//
// Return the basic information of all alert rules in a folder. For full rule details, call `POST /monit/rule/info`.
//
// API: POST /monit/rule/list/basic (monit-rule-read-list).
func (s *AlertRulesService) ReadList(ctx context.Context, req *RuleListRequest) (*RuleBasicListResponse, *Response, error) {
	out := new(RuleBasicListResponse)
	resp, err := s.client.do(ctx, "/monit/rule/list/basic", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Create alert rule.
//
// Create a new alert rule. Returns the created rule with its assigned ID.
//
// API: POST /monit/rule/create (monit-rule-write-create).
func (s *AlertRulesService) WriteCreate(ctx context.Context, req *AlertRule) (*AlertRule, *Response, error) {
	out := new(AlertRule)
	resp, err := s.client.do(ctx, "/monit/rule/create", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Delete alert rule.
//
// Delete a single alert rule by its ID.
//
// API: POST /monit/rule/delete (monit-rule-write-delete).
func (s *AlertRulesService) WriteDelete(ctx context.Context, req *RuleIDRequest) (*Response, error) {
	return s.client.do(ctx, "/monit/rule/delete", req, nil)
}

// Batch delete alert rules.
//
// Delete multiple alert rules in a single request.
//
// API: POST /monit/rule/delete/batch (monit-rule-write-delete-batch).
func (s *AlertRulesService) WriteDeleteBatch(ctx context.Context, req *RuleIDsRequest) (*Response, error) {
	return s.client.do(ctx, "/monit/rule/delete/batch", req, nil)
}

// Batch update rule fields.
//
// Update specific fields across multiple alert rules at once. Only the fields listed in `fields` are applied.
//
// API: POST /monit/rule/update/fields (monit-rule-write-fields-update).
func (s *AlertRulesService) WriteFieldsUpdate(ctx context.Context, req *RuleFieldsUpdateRequest) (*RuleNameMessageListResponse, *Response, error) {
	out := new(RuleNameMessageListResponse)
	resp, err := s.client.do(ctx, "/monit/rule/update/fields", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Import alert rules.
//
// Import one or more alert rules from a JSON array. Returns the result for each rule, indicating success or failure.
//
// API: POST /monit/rule/import (monit-rule-write-import).
func (s *AlertRulesService) WriteImport(ctx context.Context, req *RuleImportRequest) (*RuleImportResponse, *Response, error) {
	out := new(RuleImportResponse)
	resp, err := s.client.do(ctx, "/monit/rule/import", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Move alert rules to folder.
//
// Move one or more alert rules to a different folder.
//
// API: POST /monit/rule/move (monit-rule-write-move).
func (s *AlertRulesService) WriteMove(ctx context.Context, req *RuleMoveRequest) (*RuleNameMessageListResponse, *Response, error) {
	out := new(RuleNameMessageListResponse)
	resp, err := s.client.do(ctx, "/monit/rule/move", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Get rule trigger status under folder.
//
// Return the rule trigger summary for all rules under a folder node and its descendants.
//
// API: POST /monit/rule/status (monit-rule-write-status).
func (s *AlertRulesService) WriteStatus(ctx context.Context, req *RuleFolderIDRequest) (*RuleStatusResponse, *Response, error) {
	out := new(RuleStatusResponse)
	resp, err := s.client.do(ctx, "/monit/rule/status", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}

// Update alert rule.
//
// Replace the full configuration of an existing alert rule. All fields are overwritten.
//
// API: POST /monit/rule/update (monit-rule-write-update).
func (s *AlertRulesService) WriteUpdate(ctx context.Context, req *AlertRule) (*AlertRule, *Response, error) {
	out := new(AlertRule)
	resp, err := s.client.do(ctx, "/monit/rule/update", req, out)
	if err != nil {
		return nil, resp, err
	}
	return out, resp, nil
}