// Synthetics data and admin APIs

syntax = "proto3";

package kentik.synthetics.v202309;
option go_package = "github.com/kentik/api-schema-public/gen/go/kentik/synthetics/v202309;synthetics";

import "google/api/annotations.proto";
import "google/api/client.proto";
import "google/api/field_behavior.proto";
import "google/protobuf/timestamp.proto";
import "protoc-gen-openapiv2/options/annotations.proto";

import "kentik/core/v202303/annotations.proto";
import "kentik/core/v202303/user_info.proto";

option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
  info: {
    title: "Synthetics Monitoring API"
    version: "v202309"
    contact: {
      name: "Kentik API Engineering"
      url: "https://github.com/kentik/api-schema-public"
    }
    description: "# Overview\n"
	"The Synthetics Monitoring API provides programmatic access to Kentik's [synthetic monitoring system](https://kb.kentik.com/v4/Ma00.htm). The API consists of two endpoints:\n"
		"| Endpoint | Purpose |\n"
		"|-----------|---------|\n"
		"| SyntheticsAdminService | CRUD operations for synthetic tests, agents, and offline agent alerts |\n"
		"| SyntheticsDataService  | Retrieval of synthetic test results and network traces |\n"
	"\n"
	"Both REST endpoint and gRPC RPCs are provided.\n"
  "Note: API version v202309 is the same as v202202 except that the timestamps returned for synthetic test results are closer to when the test was actually run.\n"
	"### Known Limitations\n"
	"The API currently does not support the following [Synthetic Test Types](https://kb.kentik.com/v4/Ma00.htm#Ma00-Synthetic_Test_Types):\n"
	"* BGP Monitor tests, which are supported in a [separate API](https://github.com/kentik/api-schema-public/blob/master/proto/kentik/bgp_monitoring/v202205beta1/bgp_monitoring.proto)\n"
	"* Transaction tests.\n"
	"\n"
	"### Additional Public Resources\n"
	"Kentik community [Python](https://github.com/kentik/community_sdk_python) and "
  "[Go](https://github.com/kentik/community_sdk_golang) SDKs provide language-specific support for using this and other"
  " Kentik APIs. These SDKs can be also used as example code for development. \n"
	" A [Terraform provider](https://registry.terraform.io/providers/kentik/kentik-synthetics) is available for "
  "configuring tests and agents for Kentik synthetic monitoring.\n"
	"# Anatomy of a Synthetic Test\n"
	"Each `Test` consists of one or more tasks. Tasks are executed by monitoring `Agents` that send synthetic traffic "
  "(probes) over the network. The API currently supports following tasks:\n"
		"| Task name  | Purpose |\n"
		"|------------|---------|\n"
		"| ping       | Test basic address, and optionally TCP port reachability |\n"
		"| traceroute (a.k.a. trace)| Discover unidirectional network path |\n"
		"| http | Perform a simple HTTP/HTTPS request |\n"
		"| page-load | Use headless Chromium to execute an HTTP/HTTPS request |\n"
		"| dns | Execute a DNS query|\n"
    "| throughput | Execute a throughput task to determine bandwidth |\n"
	"\n"
	"The set of tasks executed on behalf of a given test depends on the `type` of that test. The following test types "
  "are currently supported by the API:\n"
		"| API type | Portal (UI) equivalent | Tasks |\n"
		"|---------------|--------------|-------|\n"
		"| ip | IP Address | ping, traceroute |\n"
		"| hostname | Hostname | ping, traceroute |\n"
		"| network_grid | Network Grid | ping, traceroute |\n"
		"| agent | Agent-to-Agent | ping, traceroute, throughput |\n"
		"| network_mesh | Network Mesh | ping, traceroute |\n"
		"| flow | Autonomous Tests (5 variants) | ping, traceroute |\n"
		"| url | HTTP(S) or API | http, ping (optional), traceroute (optional) |\n"
		"| page_load | Page Load | page-load, ping (optional), traceroute (optional) |\n"
		"| dns | DNS Server Monitor | dns |\n"
		"| dns_grid | DNS Server Grid | dns |\n"
	"\n"
	"***Note:*** `ping` and `traceroute` tasks are always run together (never one without the other).\n"
	"\n"
	"# Test Attributes and Settings\n"
	"The attributes of the test object enable configuration of test settings, access to test metadata, and access to "
  "runtime state information.\n"
	"### State and Metadata Attributes\n"
  " The following table lists the metadata and state attributes:\n"
		"| Attribute | Access | Purpose |\n"
		"|-----------|--------|---------|\n"
		"| id | RO | System-generated unique identifier of the test |\n"
		"| name | RW | User specified name for the test (need not be unique) |\n"
		"| type | RO (after creation) | Type of the test (set on creation; read-only thereafter) |\n"
		"| status | RW | Life-cycle status of the test |\n"
		"| cdate | RO | Creation timestamp |\n"
		"| edate | RO | Last-modification timestamp |\n"
		"| created_by | RO | Identity of the user that created the test |\n"
		"| last_updated_by | RO | Identity of the latest user to modify the test |\n"
		"| labels | RW | List of names of labels applied to the test |\n"
	"\n"
	"Test configuration is performed via the test's `settings` attribute. Some settings are common to all tests while "
  "others are specific to tests of a given type.\n"
	"### Common Test Settings\n"
	"The following settings are used for tests of all types:\n"
		"| Attribute | Purpose | Required |\n"
		"|-----------|---------|----------|\n"
		"| agentIds  | IDs of agents to execute tasks for the test | YES |\n"
		"| period | Test execution interval in seconds | NO (default 60s) |\n"
		"| family | IP address family. Used only for tests whose type is url or dns. Selects which type of DNS resource is queried for resolving hostname to target address | NO (default IP_FAMILY_DUAL) |\n"
		"| notificationChannels | List of notification channels for the test | NO (default empty list) |\n"
		"| healthSettings | A HealthSettings object that configures health settings for this test, which includes metric thresholds that define health status (warning and critical) and trigger associated alarms. | YES |\n"
		"| ping | A TestPingSettings object that configures the ping task of the test | NO (default depends on test type) |\n"
		"| trace | A TestTraceSettings object that configures the trace task of the test | NO (default depends on test type) |\n"
    "| throughput | A TestThroughputSettings object that configures the throughput task of the test | NO (default depends on test type) |\n"
		"| tasks | List of names of the tasks that will be executed for this test | YES |\n"
	"\n"
	"### Type-specific Settings\n"
	"Each test type has its own configuration object that represents the settings for that type. These type-specific "
  "objects are referenced by the attributes in `Test.settings`:\n"
		"| Test type    | Settings attribute | Configuration object |\n"
		"|--------------|-------------------------|---------------------------|\n"
		"| ip           | ip                      | IpTest                    |\n"
		"| hostname     | hostname                | HostnameTest              |\n"
		"| network_grid | networkGrid             | IpTest                    |\n"
		"| agent        | agent                   | AgentTest                 |\n"
		"| network_mesh | networkMesh             | NetworkMeshTest           |\n"
		"| flow         | flow                    | FlowTest                  |\n"
		"| url          | url                     | UrlTest                   |\n"
		"| page_load    | pageLoad                | PageLoadTest              |\n"
		"| dns          | dns                     | DnsTest                   |\n"
		"| dns_grid     | dnsGrid                 | DnsTest                   |\n"
	"\n"
	"# Test Results\n"
	"Results of synthetic tests are returned as a sequence of `TestResults` objects. Each such object represents "
  "measurements and health evaluation for a single test at specific point in time. Measurements and health evaluation "
  "are grouped by agent and by task.\n"
	"Granularity of timestamps in test results depends on the frequency (period) of the test and on the requested time "
  "range. The minimum granularity is 1 minute (even when period < 1 minute). The longer the time range, the lower the "
  "granularity.\n"
	"# Network Traces\n"
	"Synthetic tests that include the `traceroute` task collect the unidirectional network path from the agent to the "
  "target for each agent/target pair. The trace data are returned in the `GetTraceForTestResponse` object. The `paths` "
  "attribute of this object contains the collected network path for each agent/target pair and the round-trip time (RTT)"
  " to each hop.\n"
	"Hops in actual network traces are identified by a `nodeId`. The mapping of node IDs to address, name, location, and "
  "other attributes of the hop is provided in a map that is stored in the `nodes` attribute of the "
  "`GetTraceForTestResponse` object.\n"
	"# Agents\n"
	"The Kentik synthetic monitoring system recognizes 2 types of agents:\n"
	"* **Global** (public): Managed by Kentik and available to every Kentik user. All information about global agents"
  " in this API is read-only.\n"
	"* **Private**: Deployed by each customer and available only to that customer.\n"
  "To be visible in this API, a private agent must first associate itself with a customer account by contacting the "
  "Kentik system (via private API). Once the agent is associated it can be authorized via the API by changing its "
  "`status` to `AGENT_STATUS_OK`. For more information about private agent deployment, see "
  "[**Synthetic Agent Deployments**](https://kb.kentik.com/v4/Ma01.htm#Ma01-Synthetic_Agent_Deployments).\n"
  }
  external_docs: {
    url: "https://kb.kentik.com/v4/Ma00.htm#Ma00-Synthetics_Overview"
    description: "Kentik synthetic monitoring system"
  }
  schemes: HTTPS
  consumes: "application/json"
  produces: "application/json"
  security_definitions: {
    security: {
      key: "email"
      value: {
        type: TYPE_API_KEY
        in: IN_HEADER
        name: "X-CH-Auth-Email"
      }
    }
    security: {
      key: "token"
      value: {
        type: TYPE_API_KEY
        in: IN_HEADER
        name: "X-CH-Auth-API-Token"
      }
    }
  }
  security: {
    security_requirement: {
      key: "email"
      value: {}
    }
    security_requirement: {
      key: "token"
      value: {}
    }
  }
};

// models
// -------------------------------------------------------
// === AGENT config and status ===

// {{.Name}}
enum ImplementType {
  IMPLEMENT_TYPE_UNSPECIFIED = 0;
  // ksynth, a.k.a network agent (implemented in Rust) capable of running all tasks except for page-load and transaction
  IMPLEMENT_TYPE_RUST = 1;
  // ksynth-agent, a.k.a. app agent (implemented in NodeJS) with Chromium enabled capable of running all tasks
  IMPLEMENT_TYPE_NODE = 2;
  // ksynth-agent, a.k.a. app agent with Chromium disabled, capable of running all tasks except for page-load and transaction
  IMPLEMENT_TYPE_NETWORK = 3;
}

message DisabledMetrics {
  bool ping_latency = 1;
  bool ping_jitter = 2;
  bool ping_packet_loss = 3;
  bool http_latency = 4;
  bool http_headers = 5;
  bool http_codes = 6;
  bool http_cert_expiry = 7;
  bool transaction_latency = 8;
  bool dns_latency = 9;
  bool dns_codes = 10;
  bool dns_ips = 11;
  bool throughput_bandwidth = 12;
}

// {{.Name}}
message Agent {
  string id = 1 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Unique identifier of the agent"
    }
  ];
  string site_name = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Name of the site where agent is located"
    }
  ];
  AgentStatus status = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Operational status"
    }
  ];
  string alias = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "User selected descriptive name of the agent"
    }
  ];
  string type = 5 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Type of agent (global | private)"
    }
    ];
  string os = 6 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "OS version of server/VM hosting the agent"
    }
    ];
  string ip = 7 [
    deprecated=true,
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Public IP address of the agent (auto-detected)"
    }
    ];
  double lat = 8 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Latitude of agent's location (signed decimal degrees)"
    }
  ];
  double long = 9 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Longitude of agent's location (signed decimal degrees)"
    }
  ];
  google.protobuf.Timestamp last_authed = 10 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timestamp of the last authorization"
    }
  ];
  IPFamily family = 11 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "IP address family supported by the agent"
    }
  ];
  uint32 asn = 12 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ASN of the AS owning agent's public address"
    }
  ];
  string site_id = 13 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the site hosting the agent (if configured in Kentik)"
    }
  ];
  string version = 14 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Software version of the agent"
    }
  ];
  string city = 16 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "City where the agent is located"
    }
  ];
  string region = 17 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Geographical region of agent's location"
    }
  ];
  string country = 18 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Country of agent's location"
    }
  ];
  repeated string test_ids = 19 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "IDs of user's test running on the agent"
    }
  ];
  string local_ip = 20 [
    deprecated=true,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Internal IP address of the agent"
    }
  ];
  string cloud_region = 22 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Cloud region (if any) hosting the agent"
    }
  ];
  string cloud_provider = 23 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Cloud provider (if any) hosting the agent"
    }
  ];
  ImplementType agent_impl = 24 [
    (google.api.field_behavior) = OUTPUT_ONLY
  ];
  repeated string labels = 25 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of names of labels associated with the agent"
    }
  ];
  AgentMetadata metadata = 26 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Additional information about agent's configuration and run-time state"
    }
  ];
}

// {{.Name}}
message AgentMetadata {
  repeated IpValue private_ipv4_addresses = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of private IPv4 addresses"
    }
  ];
  repeated IpValue public_ipv4_addresses = 2 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of public IPv4 addresses"
    }
  ];
  repeated IpValue private_ipv6_addresses = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of private IPv6 addresses"
    }
  ];
  repeated IpValue public_ipv6_addresses = 4 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of public IPv6 addresses"
    }
  ];

  message IpValue {
    string value = 1;
  }
}

// {{.Name}}
enum IPFamily {
  // Invalid value.
  IP_FAMILY_UNSPECIFIED = 0;
  // IPv4 only
  IP_FAMILY_V4 = 1;
  // IPv6 only
  IP_FAMILY_V6 = 2;
  // IPv4 and IPv6 supported
  IP_FAMILY_DUAL = 3;
};

// {{.Name}}
enum TestStatus {
  // Invalid value.
  TEST_STATUS_UNSPECIFIED = 0;
  // Test is active.
  TEST_STATUS_ACTIVE = 1;
  // Test is paused.
  TEST_STATUS_PAUSED = 2;
  // Test is deleted. Not user settable.
  TEST_STATUS_DELETED = 3;
  // Test is preview
  TEST_STATUS_PREVIEW = 4;
}

// {{.Name}}
enum AgentStatus {
  // Invalid value.
  AGENT_STATUS_UNSPECIFIED = 0;
  // Agent is ready to accept tests
  AGENT_STATUS_OK = 1;
  // Agent is waiting for authorization
  AGENT_STATUS_WAIT = 2;
  // Agent was deleted - not user settable
  AGENT_STATUS_DELETED = 3;
}


// === TEST config and status ===

// {{.Name}}
message Test {
  string id = 1 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Unique ID of the test"
    }
  ];
  string name = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "User selected name of the test"
    }
  ];
  string type = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Type of the test"
    }
  ];
  TestStatus status = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Operational status of the test"
    }
  ];
  TestSettings settings = 6 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Test configuration"
    }
  ];
  google.protobuf.Timestamp cdate = 7 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Creation timestamp (UTC)"
    }
  ];
  google.protobuf.Timestamp edate = 8 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Last modification timestamp (UTC)"
  }
  ];
  kentik.core.v202303.UserInfo created_by = 9 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Identity of test creator"
  }
  ];
  kentik.core.v202303.UserInfo last_updated_by = 10 [
    (google.api.field_behavior) = OUTPUT_ONLY,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Identity of use that has modified the test last"
  }
  ];
  repeated string labels = 11 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Set of labels associated with the test"
    }
  ];
}

// {{.Name}}
enum DNSRecord {
  // Invalid value
  DNS_RECORD_UNSPECIFIED = 0;
  // name to IPv4 address(es) mapping
  DNS_RECORD_A = 1;
   // name to IPv6 address(es) mapping
  DNS_RECORD_AAAA = 2;
  // alternative resource name
  DNS_RECORD_CNAME = 3;
  // alternative resource set name
  DNS_RECORD_DNAME = 4;
  // domain to name server mapping
  DNS_RECORD_NS = 5;
  // SMTP mail server record
  DNS_RECORD_MX = 6;
  // IPv4/6 address to name mapping
  DNS_RECORD_PTR = 7;
  // domain meta-data
  DNS_RECORD_SOA = 8;
}

// {{.Name}}
message TestSettings {
  oneof definition {
    HostnameTest hostname = 1;
    IpTest ip = 2 ;
    AgentTest agent = 3;
    FlowTest flow = 4;
    DnsTest dns = 5;
    UrlTest url = 6;
    IpTest network_grid = 7;
    PageLoadTest page_load = 8;
    DnsTest dns_grid = 9;
    NetworkMeshTest network_mesh = 18;
  }

  repeated string agent_ids = 10 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "IDs of agents assigned to run tasks on behalf of the test"
    }
  ];
  repeated string tasks = 11 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of task names to run for the test"
    }
  ];

  HealthSettings health_settings = 12 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Health evaluation thresholds, acceptable responses and alarm activation settings"
    }
  ];
  TestPingSettings ping = 13 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Ping tasks configuration parameters"
    }
  ];
  TestTraceSettings trace = 14 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Traceroute task configuration parameters"
    }
  ];

  uint32 period = 15 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Test evaluation period (in seconds)"
    }
  ];
  IPFamily family = 16 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "IP address family to select from available DNS name resolutions"
    }
  ];
  repeated string notification_channels = 17 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of IDs of notification channels for alarms triggered by the test"
    }
  ];

  string notes = 19 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Add a note or comment for this test"
    }
  ];

  TestThroughputSettings throughput = 20 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Throughput task configuration parameters"
    }
  ];

  ScheduleSettings schedule = 21 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Scheduled test configuration parameters"
    }
  ];

  AlertingSettings alerting = 22 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Alerting configuration parameters"
    }
  ];
}

// {{.Name}}
message TestPingSettings {
  uint32 count = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Number of probe packets to send in one iteration"
    }
  ];
  string protocol = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Transport protocol to use (icmp | tcp)"
    }
  ];
  uint32 port = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Target port for TCP probes (ignored for ICMP)"
    }
  ];
  uint32 timeout = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timeout in milliseconds for execution of the task"
    }
  ];
  float delay = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Inter-probe delay in milliseconds"
    }
  ];
  uint32 dscp = 6 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "DSCP code to be set in IP header of probe packets"
    }
  ];
}

// {{.Name}}
message TestTraceSettings {
  uint32 count = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Number of probe packets to send in one iteration"
    }
  ];
  string protocol = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Transport protocol to use (icmp | tcp | udp)"
    }
  ];
  uint32 port = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Target port for TCP or UDP probes (ignored for ICMP)"
    }
  ];
  uint32 timeout = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timeout in milliseconds for execution of the task"
    }
  ];
  uint32 limit = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Maximum number of hops to probe (i.e. maximum TTL)"
    }
  ];
  float delay = 6 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Inter-probe delay in milliseconds"
    }
  ];
  uint32 dscp = 7 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "DSCP code to be set in IP header of probe packets"
    }
  ];
  bool mtu = 8 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Enable MTU in trace results"
    }
  ];
}

// {{.Name}}
message TestThroughputSettings {
  uint32 port = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Target port for TCP or UDP throughput task (the port the target server is listening on)"
    }
  ];
  uint32 omit = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "(optional) Number of seconds to omit from the start of the test"
    }
  ];
  uint32 duration = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Duration of the test in seconds"
    }
  ];
  uint32 bandwidth = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "(optional) Target bandwidth in Mbps, if no bandwidth is specified, the test will measure the maximum bandwidth for TCP and 10Mbps for UDP"
    }
  ];
  string protocol = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Transport protocol to use (tcp | udp)"
    }
  ];
}

// {{.Name}}
message ScheduleSettings {
  bool enabled = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean indicating an (dis|en)abled schedule"
    }
  ];
  uint32 start = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "UTC unix timestamps indicating the start of the schedule"
    }
  ];
  uint32 end = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "UTC unix timestamp indicating the end of the schedule"
    }
  ];
}

// {{.Name}}
message GroupedAlertSetting {
  string metric = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Metric"
    }
  ];

  SrcGroupBy src_group_by = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Grouping"
    }
  ];

  uint32 percent_of_src_group = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Grouping percentage"
    }
  ];

  repeated uint32 filter_ids = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of IDs to include in the group"
    }
  ];
}

// {{.Name}}
message GroupedAlertSettings {
  GroupedAlertSetting default = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Default grouped alerting settings"
    }
  ];

  repeated GroupedAlertSetting overrides = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Overrides to default grouped alerting settings"
    }
  ];
}

// {{.Name}}
enum AlertingType {
  // Invalid value.
  ALERTING_TYPE_UNSPECIFIED = 0;
  // Per-Agent - Generates alerts based on individual metric thresholds (This can be noisy)
  ALERTING_TYPE_AGENT = 1;
  // Grouped - Reduces the number of alert notifications for upstream issues by forcing alert conditions to exist across multiple network paths
  ALERTING_TYPE_GROUPED = 2;
  // All metrics - Calculates health and alerts for the test as a whole
  ALERTING_TYPE_SUBTEST = 3;
};

// {{.Name}}
enum SrcGroupBy {
  // Invalid value.
  SRC_GROUP_BY_UNSPECIFIED = 0;
  // Grouped by all agents
  SRC_GROUP_BY_ALL_AGENTS = 1;
  // Grouped by label
  SRC_GROUP_BY_LABEL = 2;
  // Grouped by site
  SRC_GROUP_BY_SITE = 3;
};

// {{.Name}}
message AlertingSettings {
  bool disable_warning_notifications = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean indicating whether to disable warning-level alert notifications"
    }
  ];

  AlertingType alerting_type = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Alerting type for the test"
    }
  ];

  GroupedAlertSettings grouped_alert_settings = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Grouped alerting settings"
    }
  ];
}

// {{.Name}}
message ActivationSettings {
  string grace_period = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Period of healthy status in minutes within the time window not cancelling alarm activation"
    }
  ];
  string time_unit = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Time unit for specifying time window (m | h)"
    }
  ];
  string time_window = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Time window for evaluating of test for alarm activation"
    }
  ];
  string times = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Number of occurrences of unhealthy test status within the time window triggering alarm activation"
    }
  ];
}

// {{.Name}}
message HealthSettings {
  float latency_critical = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for ping response latency (in microseconds) to trigger critical alarm"
    }
  ];
  float latency_warning = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for ping response latency (in microseconds) to trigger warning alarm"
    }
  ];
  float packet_loss_critical = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for ping packet loss (in %) to trigger critical alarm"
    }
  ];
  float packet_loss_warning = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for ping packet loss (in %) to trigger warning alarm"
    }
  ];
  float jitter_critical = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for ping jitter (in microseconds) to trigger critical alarm"
    }
  ];
  float jitter_warning = 6 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for ping jitter (in microseconds) to trigger critical alarm"
    }
  ];
  float http_latency_critical = 7 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for HTTP response latency (in microseconds) to trigger critical alarm"
    }
  ];
  float http_latency_warning = 8 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for HTTP response latency (in microseconds) to trigger warning alarm"
    }
  ];
  repeated uint32 http_valid_codes = 9 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of HTTP status codes indicating healthy state"
    }
  ];
  repeated uint32 dns_valid_codes = 10 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of DNS status codes indicating healthy state"
    }
  ];
  float latency_critical_stddev = 11 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation (in microseconds) of ping response latency to trigger critical alarm"
    }
  ];
  float latency_warning_stddev = 12 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation (in microseconds) of ping response latency to trigger warning alarm"
    }
  ];
  float jitter_critical_stddev = 13 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation of ping jitter (in microseconds) to trigger critical alarm"
    }
  ];
  float jitter_warning_stddev = 14 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation of ping jitter (in microseconds) to trigger warning alarm"
    }
  ];
  float http_latency_critical_stddev = 15 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation of HTTP response latency (in microseconds) to trigger critical alarm"
    }
  ];
  float http_latency_warning_stddev = 16 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation of HTTP response latency (in microseconds) to trigger warning alarm"
    }
  ];
  uint32 unhealthy_subtest_threshold = 17 [
    deprecated = true,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Number of tasks (across all agents) that must report unhealthy status in order for alarm to be triggered"
    }
  ];
  ActivationSettings activation = 18 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Alarm activation settings"
    }
  ];
  uint32 cert_expiry_warning = 19 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for remaining validity of TLS certificate (in days) to trigger warning alarm"
    }
  ];
  uint32 cert_expiry_critical = 20 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for remaining validity of TLS certificate (in days) to trigger critical alarm"
    }
  ];
  string dns_valid_ips = 21 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Comma separated list of IP addresses expected to be received in response to DNS A or AAAA query"
    }
  ];
  float dns_latency_critical = 22 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for DNS response latency (in microseconds) to trigger critical alarm"
    }
  ];
  float dns_latency_warning = 23 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for DNS response latency (in microseconds) to trigger warning alarm"
    }
  ];
  float dns_latency_critical_stddev = 24 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation (in microseconds) of DNS response latency to trigger critical alarm"
    }
  ];
  float dns_latency_warning_stddev = 25 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation (in microseconds) of DNS response latency to trigger warning alarm"
    }
  ];
  bool per_agent_alerting = 26 [
    deprecated = true,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean value indicating whether to use per-agent alerting"
    }
  ];
  DisabledMetrics disabled_metrics = 27 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Set of metrics to be skipped during health evaluation"
    }
  ];
  bool health_disabled = 28 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Disable all health evaluation for this test"
    }
  ];
  float throughput_critical = 29 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for throughput bandwidth (in mbps) to trigger critical alarm"
    }
  ];
  float throughput_warning = 30 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for throughput bandwidth (in mbps) to trigger warning alarm"
    }
  ];
  float throughput_critical_stddev = 31 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation (in mbps) of throughput bandwidth to trigger critical alarm"
    }
  ];
  float throughput_warning_stddev = 32 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Threshold for standard deviation (in mbps) of throughput bandwidth to trigger warning alarm"
    }
  ];
  bool disable_alerts = 33 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean value indicating whether to disable all alerts for this test"
    }
  ];
}

// {{.Name}}
message HostnameTest {
  string target = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Fully qualified DNS name of the target host"
    }
  ];
}

// {{.Name}}
message IpTest {
  repeated string targets = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of IP addresses of targets"
    }
  ];
  bool use_local_ip = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean value indicating whether to use local (private) IP address of the target agents"
    }
  ];
}

// {{.Name}}
message AgentTest {
  string target = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the target agent"
    }
  ];
  bool use_local_ip = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean value indicating whether to use local (private) IP address of the target agent"
    }
  ];
  bool reciprocal = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean value indicating whether to make the test bidirectional"
    }
  ];
}

// {{.Name}}
message FlowTest {
  string target = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Target ASN, CDN, Country, Region of City for autonomous test (type of value depends on flow test sub-type)"
    }
  ];
  uint32 target_refresh_interval_millis = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Period (in milliseconds) for refreshing list of targets based on available flow data"
    }
  ];
  uint32 max_providers = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Maximum number of IP providers to track autonomously"
    }
  ];
  uint32 max_ip_targets = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Maximum number of target IP addresses to select based flow data query"
    }
  ];
  string type = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Autonomous test sub-type (asn | cdn | country | region | city)"
    }
  ];
  string inet_direction = 6 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Selection of address from flow data (src = source address in inbound flows | dst = destination addresses in outbound flows)"
    }
  ];
  string direction = 7 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Direction of flows to match target attribute for extraction of target addresses (src | dst)"
    }
  ];
}

// {{.Name}}
message DnsTest {
  string target = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Fully qualified DNS name to query"
    }
  ];
  uint32 timeout = 2 [
    deprecated = true,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "--- Deprecated: value is ignored. ---"
    }
  ];
  DNSRecord record_type = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Type of DNS record to query"
    }
  ];
  repeated string servers = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of IP addresses of DNS servers"
    }
  ];
  uint32 port = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Target DNS server port"
    }
  ];
}

// {{.Name}}
message UrlTest {
  string target = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "HTTP or HTTPS URL to request"
    }
  ];
  uint32 timeout = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "HTTP transaction timeout (in milliseconds)"
    }
  ];
  string method = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "HTTP method to use (GET | HEAD | PATCH | POST | PUT)"
    }
  ];
  map<string, string> headers = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Map of HTTP header values keyed by header names"
    }
  ];
  string body = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "HTTP request body"
    }
  ];
  bool ignore_tls_errors = 6 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean indicating whether to ignore TLS certificate verification errors"
    }
  ];
}

// {{.Name}}
message PageLoadTest {
  string target = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "HTTP or HTTPS URL to request"
    }
  ];
  uint32 timeout = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "HTTP transaction timeout (in milliseconds)"
    }
  ];
  map<string, string> headers = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Map of HTTP header values keyed by header names"
    }
  ];
  bool ignore_tls_errors = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean indicating whether to ignore TLS certificate verification errors"
    }
  ];
  map<string, string> css_selectors = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Map of CSS selector values keyed by selector name"
    }
  ];
}


// {{.Name}}
message NetworkMeshTest {
  bool use_local_ip = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Boolean value indicating whether to use local (private) IP address of the target agents"
    }
  ];
}

// === TEST RESULTS

// {{.Name}}
message MetricData {
  uint32 current = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Current value of metric"
    }
  ];
  uint32 rolling_avg = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Rolling average of metric"
    }
  ];
  uint32 rolling_stddev = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Rolling average of standard deviation of metric"
    }
  ];
  string health = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Health evaluation status for the metric (healthy | warning | critical)"
    }
  ];
}

// {{.Name}}
message PacketLossData {
  double current = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Current packet loss value"
    }
  ];
  string health = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Health evaluation status for the metric (healthy | warning | critical)"
    }
  ];
}

// {{.Name}}
message PingResults {
  string target = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Hostname or address of the probed target"
    }
  ];
  PacketLossData packet_loss = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Packet loss metric and health"
    }
  ];
  MetricData latency = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Packet latency metric and health"
    }
  ];
  MetricData jitter = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Latency jitter (variance) metric and health"
    }
  ];
  string dst_ip = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "IP address of probed target"
    }
  ];
}

// {{.Name}}
message HTTPResponseData {
  uint32 status = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "HTTP status in response"
    }
  ];
  uint32 size = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Total size of  received response body"
    }
  ];
  string data = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Detailed information about transaction timing, connection characteristics and response"
    }
  ];
}

// {{.Name}}
message HTTPResults {
  string target = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Target probed URL"
    }
  ];
  MetricData latency = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "HTTP response latency metric and health"
    }
  ];
  HTTPResponseData response = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Information about received HTTP response"
    }
  ];
  string dst_ip = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "IP address of probed target server"
    }
  ];
}

// {{.Name}}
message DNSResponseData {
  uint32 status = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Received DNS status"
    }
  ];
  string data = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Text rendering of received DNS resolution"
    }
  ];
}

// {{.Name}}
message DNSResults {
  string target = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Queried DNS record"
    }
  ];
  string server = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "DNS server used for the query"
    }
  ];
  MetricData latency = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "DNS response latency metric and health"
    }
  ];
  DNSResponseData response = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Information about received DNS response"
    }
  ];
}

// {{.Name}}
message TaskResults {
  oneof task_type {
    PingResults ping = 1 [
      (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
        description: "Entry containing ping task results"
      }
    ];
    HTTPResults http = 2 [
      (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
        description: "Entry containing HTTP task results"
      }
    ];
    DNSResults dns = 3 [
      (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
        description: "Entry containing DNS task results"
      }
    ];
  }
  string health = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Health status of the task"
    }
  ];
}

// {{.Name}}
message AgentResults {
  string agent_id = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the agent providing results"
    }
  ];
  string health = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Overall health status of all task for the test executed by this agent"
    }
  ];
  repeated TaskResults tasks = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of results for individual tasks"
    }
  ];
}

// {{.Name}}
message TestResults {
  string test_id = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the test for which results are provided"
    }
  ];
  google.protobuf.Timestamp time = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Results timestamp (UTC)"
    }
  ];
  string health = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Health status of the test"
    }
  ];
  repeated AgentResults agents = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of results from agents executing tasks on behalf of the test"
    }
  ];
}

// === TEST TRACE results ===

// {{.Name}}
message Stats {
  int32 average = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Average value"
    }
  ];
  int32 min = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Minimum value"
    }
  ];
  int32 max = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Maximum value"
    }
  ];
}

// {{.Name}}
message Location {
  double latitude = 8 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Latitude in signed decimal degrees"
    }
  ];
  double longitude = 9 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Longitude in signed decimal degrees"
    }
  ];
  string country = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Country of the location"
    }
  ];
  string region = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Geographic region within the country"
    }
  ];
  string city = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "City of the location"
    }
  ];
}

// {{.Name}}
message NetNode {
  string ip = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "IP address of the node in standard textual notation"
    }
  ];
  uint32 asn = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "AS number owning the address of the node"
    }
  ];
  string as_name = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Name of the AS owning the address of the node"
    }
  ];
  Location location = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Location of IP address of the node"
    }
  ];
  string dns_name = 6 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "DNS name of the node (obtained by reverse DNS resolution)"
    }
  ];
  string device_id = 7 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the device corresponding with the node in Kentik configuration"
    }
  ];
  string site_id = 8 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the site containing the device corresponding with the node in Kentik configuration"
    }
  ];
}

// {{.Name}}
message TraceHop {
  int32 latency = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Round-trip packet latency to the node (in microseconds) - 0 if no response was received"
    }
  ];

  string node_id = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the node for this hop in the Nodes map  - empty if no response was received"
    }
  ];
}

// {{.Name}}
message PathTrace {
  repeated int32 as_path = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "AS path of the network trace"
    }
  ];
  bool is_complete = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Indication whether response from target was received"
    }
  ];
  repeated TraceHop hops = 6 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of hops in the trace"
    }
  ];
}

// {{.Name}}
message Path {
  string agent_id = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the agent generating the path data"
    }
  ];
  string target_ip = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "IP address of the target of the path"
    }
  ];
  Stats hop_count = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Hop count statistics across all traces"
    }
  ];
  int32 max_as_path_length = 7 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Maximum length of AS path across all traces"
    }
  ];
  repeated PathTrace traces = 8 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Data for individual traces"
    }
  ];
  google.protobuf.Timestamp time = 9 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timestamp (UTC) of initiation of the path trace"
    }
  ];
}


// Data Service
// -------------------------------------------------------

// {{.Name}}
message GetResultsForTestsRequest {
  repeated string ids = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of test IDs for which to retrieve results"
    },
    (google.api.field_behavior) = REQUIRED
  ];

  google.protobuf.Timestamp start_time = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timestamp of the oldest results to include in results"
    },
    (google.api.field_behavior) = REQUIRED
  ];

  google.protobuf.Timestamp end_time = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timestamp of the newest results to include in results"
    },
    (google.api.field_behavior) = REQUIRED
  ];

  repeated string agent_ids = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of agent IDs from which to return results"
    }
  ];

  repeated string targets = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of targets (test dependent) for which to retrieve results"
    }
  ];

  bool aggregate = 6 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "If true, retrieve result aggregated across the requested time period, else return complete time series"
    }
  ];
}

message GetResultsForTestsCsvRequest {
  repeated string ids = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of test IDs for which to retrieve results"
    },
    (google.api.field_behavior) = REQUIRED
  ];

  google.protobuf.Timestamp start_time = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timestamp of the oldest results to include in results"
    },
    (google.api.field_behavior) = REQUIRED
  ];

  google.protobuf.Timestamp end_time = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timestamp of the newest results to include in results"
    },
    (google.api.field_behavior) = REQUIRED
  ];

  repeated string agent_ids = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of agent IDs from which to return results"
    }
  ];

  bool aggregate = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "If true, retrieve result aggregated across the requested time period, else return complete time series"
    }
  ];
}

// {{.Name}}
message GetResultsForTestsCsvResponse {
  string content_type = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Content type of the response hardcoded to 'text/csv'"
    }
  ];

  bytes data = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "CSV data as byte array"
    }
  ];
}

// {{.Name}}
message GetResultsForTestsResponse {
  repeated TestResults results = 1;
}

// {{.Name}}
message GetTraceForTestRequest {
  string id = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of test for which to retrieve network path trace data"
    }
  ];

  google.protobuf.Timestamp start_time = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timestamp of the oldest results to include in results"
    },
    (google.api.field_behavior) = REQUIRED
  ];

  google.protobuf.Timestamp end_time = 3 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Timestamp of the newest results to include in results"
    },
    (google.api.field_behavior) = REQUIRED
  ];

  repeated string agent_ids = 4 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of agent IDs from which to return results"
    }
  ];

  repeated string target_ips = 5 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of target IP addresses for which to retrieve results"
    }
  ];
}

// {{.Name}}
message GetTraceForTestResponse {
  map<string, NetNode>  nodes = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Map of network node information keyed by node IDs"
    }
  ];
  repeated Path paths = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of retrieved network path data"
    }
  ];
}

service SyntheticsDataService {
  option (google.api.default_host) = "grpc.api.kentik.com";
  option (kentik.core.v202303.visibility) = SERVICE_VISIBILITY_PUBLIC;
  option (kentik.core.v202303.service_scope) = "synthetics";

  // Get measurement results for a set of tests
  rpc GetResultsForTests (GetResultsForTestsRequest) returns (GetResultsForTestsResponse) {
    option (kentik.core.v202303.method_scope) = "synthetics:read";
    option (google.api.http) = {
      post: "/synthetics/v202309/results"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "GetResultsForTests"
      summary: "Get results for tests"
      description: "Returns probe results for a set of tests for specified period of time."
    };
  }

  rpc GetResultsForTestsCsv (GetResultsForTestsCsvRequest) returns (GetResultsForTestsCsvResponse) {
    option (kentik.core.v202303.method_scope) = "synthetics:read";
    option (google.api.http) = {
      post: "/synthetics/v202309/results/csv"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "GetResultsForTestsCsv"
      summary: "Get test results in CSV format"
      description: "Returns probe results for tests in CSV format."
    };
  }

  rpc GetTraceForTest (GetTraceForTestRequest) returns (GetTraceForTestResponse) {
    option (kentik.core.v202303.method_scope) = "synthetics:read";
    option (google.api.http) = {
      post: "/synthetics/v202309/trace"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "GetTraceForTest"
      summary: "Get network trace data for a test"
      description: "Get network trace data for a specific synthetic test. The test must have traceroute task configured."
    };
  }
}

// Admin Service
// -------------------------------------------------------

// {{.Name}}
message ListAgentsRequest {}

// {{.Name}}
message ListAgentsResponse {
  repeated Agent agents = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of available agents"
    }
  ];
  uint32 invalid_count = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Number of invalid entries encountered while collecting data"
    }
  ];
}

// {{.Name}}
message GetAgentRequest {
  string id = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the requested agent"
    },
    (google.api.field_behavior) = REQUIRED
  ];
}

// {{.Name}}
message GetAgentResponse {
  Agent agent = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Agent configuration and status data"
    }
  ];
}

// {{.Name}}
message UpdateAgentRequest {
  Agent agent = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Agent configuration data"
    }
  ];
}

// {{.Name}}
message UpdateAgentResponse {
  Agent agent = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Agent configuration and status data"
    }
  ];
}

// {{.Name}}
message DeleteAgentRequest {
  string id = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the agent to be deleted"
    },
    (google.api.field_behavior) = REQUIRED
  ];
}

// {{.Name}}
message DeleteAgentResponse {}

// {{.Name}}
message ListTestsRequest {}

// {{.Name}}
message ListTestsResponse {
  repeated Test tests = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "List of configured active or paused tests"
    }
  ];
  uint32 invalid_count = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Number of invalid entries encountered while collecting data"
    }
  ];
}

// {{.Name}}
message CreateTestRequest {
  Test test = 1[
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Test configuration data"
    },
    (google.api.field_behavior) = REQUIRED
  ];
}

// {{.Name}}
message CreateTestResponse {
  Test test = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Test configuration and status data"
    }
  ];
}

// {{.Name}}
message GetTestRequest {
  string id = 1[
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of requested test"
    },
    (google.api.field_behavior) = REQUIRED
  ];
}

// {{.Name}}
message GetTestResponse {
  Test test = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Test configuration and status data"
    }
  ];
}

// {{.Name}}
message UpdateTestRequest {
  Test test = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Test configuration data"
    }
  ];
}

// {{.Name}}
message UpdateTestResponse {
  Test test = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Test configuration and status data"
    }
  ];
}

// {{.Name}}
message DeleteTestRequest {
  string id = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the test to be deleted"
    },
    (google.api.field_behavior) = REQUIRED
  ];
}

// {{.Name}}
message DeleteTestResponse {}

// {{.Name}}
message SetTestStatusRequest {
  string id = 1 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "ID of the test which status is to be modified"
    },
    (google.api.field_behavior) = REQUIRED
  ];
  TestStatus status = 2 [
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Target test status"
    },
    (google.api.field_behavior) = REQUIRED
  ];
}

// {{.Name}}
message SetTestStatusResponse {}

message AgentAlert {
  string id = 1;
  uint32 threshold_seconds = 2;
  repeated string notification_channel_ids = 3;
  string agent_id = 4;
  string agent_name = 5;
}

message CreateAgentAlertRequest {
  uint32 threshold_seconds = 1;
  repeated string notification_channel_ids = 2;
  string agent_id = 3;
}

message CreateAgentAlertResponse {
  AgentAlert agent_alert = 1;
}

message UpdateAgentAlertRequest {
  string id = 1;
  uint32 threshold_seconds = 2;
  repeated string notification_channel_ids = 3;
}

message UpdateAgentAlertResponse {
  AgentAlert agent_alert = 1;
}

message GetAgentAlertRequest {
  string id = 1;
}

message GetAgentAlertResponse {
  AgentAlert agent_alert = 1;
}

message ListAgentAlertsRequest {
  repeated string agent_ids = 1; // Optional list of agent ids to retrieve alert configurations for
}

message ListAgentAlertsResponse {
  repeated AgentAlert agent_alerts = 1;
}

message DeleteAgentAlertRequest {
  string id = 1;
}

message DeleteAgentAlertResponse {}

service SyntheticsAdminService {
  option (google.api.default_host) = "grpc.api.kentik.com";
  option (kentik.core.v202303.visibility) = SERVICE_VISIBILITY_PUBLIC;
  option (kentik.core.v202303.service_scope) = "admin.synthetics";

  rpc ListAgents(ListAgentsRequest) returns (ListAgentsResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:read";
    option (kentik.core.v202303.method_permission) = "synthetics.agent::read";

    option (google.api.http) = {
      get: "/synthetics/v202309/agents"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "ListAgents"
      summary: "List available agents"
      description: "Returns list of all synthetic agents available in the account."
    };
  }

  rpc GetAgent(GetAgentRequest) returns (GetAgentResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:read";
    option (kentik.core.v202303.method_permission) = "synthetics.agent::read";
    option (google.api.http) = {
      get: "/synthetics/v202309/agents/{id}"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "GetAgent"
      summary: "Get information about an agent"
      description: "Returns information about the requested synthetic agent."
    };
  }

  rpc UpdateAgent(UpdateAgentRequest) returns (UpdateAgentResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:write";
    option (kentik.core.v202303.method_permission) = "synthetics.agent::update";
    option (google.api.http) = {
      put: "/synthetics/v202309/agents/{agent.id}"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "UpdateAgent"
      summary: "Update configuration of an agent"
      description: "Update configuration of a synthetic agent."
    };
  }

  rpc DeleteAgent(DeleteAgentRequest) returns (DeleteAgentResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:write";
    option (kentik.core.v202303.method_permission) = "synthetics.agent::delete";
    option (google.api.http) = {
      delete: "/synthetics/v202309/agents/{id}"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "DeleteAgent"
      summary: "Delete an agent"
      description: "Deletes the requested agent. The deleted agent is removed from configuration of all tests."
    };
  }

  rpc ListTests(ListTestsRequest) returns (ListTestsResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:read";
    option (kentik.core.v202303.method_permission) = "synthetics.test::read";
    option (google.api.http) = {
      get: "/synthetics/v202309/tests"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "ListTests"
      summary: "List all tests"
      description: "Returns a list of all configured active and paused synthetic tests."
    };
  }

  rpc CreateTest(CreateTestRequest) returns (CreateTestResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:write";
    option (kentik.core.v202303.method_permission) = "synthetics.test::create";
    option (google.api.http) = {
      post: "/synthetics/v202309/tests"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "CreateTest"
      summary: "Create a test"
      description: "Create synthetic test based on configuration provided in the request."
    };
  }

  rpc GetTest(GetTestRequest) returns (GetTestResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:read";
    option (kentik.core.v202303.method_permission) = "synthetics.test::read";
    option (google.api.http) = {
      get: "/synthetics/v202309/tests/{id}"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "GetTest"
      summary: "Get information about a test"
      description: "Returns configuration and status for the requested synthetic test."
    };
  }

  rpc UpdateTest(UpdateTestRequest) returns (UpdateTestResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:write";
    option (kentik.core.v202303.method_permission) = "synthetics.test::update";
    option (google.api.http) = {
      put: "/synthetics/v202309/tests/{test.id}"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "UpdateTest"
      summary: "Update configuration of a test"
      description: "Updates configuration of a synthetic test."
    };
  }

  rpc DeleteTest(DeleteTestRequest) returns (DeleteTestResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:write";
    option (kentik.core.v202303.method_permission) = "synthetics.test::delete";
    option (google.api.http) = {
      delete: "/synthetics/v202309/tests/{id}"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "DeleteTest"
      summary: "Delete a synthetic test."
      description: "Deletes the synthetics test. All accumulated results for the test cease to be accessible."
    };
  }

  rpc SetTestStatus(SetTestStatusRequest) returns (SetTestStatusResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:write";
    option (kentik.core.v202303.method_permission) = "synthetics.test::update";
    option (google.api.http) = {
      put: "/synthetics/v202309/tests/{id}/status"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "SetTestStatus"
      summary: "Update status of a synthetic test"
      description: "Update status of a synthetic test"
    };
  }

  rpc CreateAgentAlert(CreateAgentAlertRequest) returns (CreateAgentAlertResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:write";
    option (kentik.core.v202303.method_permission) = "synthetics.agent::create";
    option (google.api.http) = {
      post: "/synthetics/v202309/agentAlerts"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "CreateAgentAlert"
      summary: "Create an agent alert configuration"
      description: "Creates a new agent alert configuration."
    };
  }

  rpc UpdateAgentAlert(UpdateAgentAlertRequest) returns (UpdateAgentAlertResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:write";
    option (kentik.core.v202303.method_permission) = "synthetics.agent::update";
    option (google.api.http) = {
      put: "/synthetics/v202309/agentAlerts/{id}"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "UpdateAgentAlert"
      summary: "Update an agent alert configuration"
      description: "Updates an existing agent alert configuration with the time threshold and notification channels provided."
    };
  }

  rpc GetAgentAlert(GetAgentAlertRequest) returns (GetAgentAlertResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:read";
    option (kentik.core.v202303.method_permission) = "synthetics.agent::read";
    option (google.api.http) = {
      get: "/synthetics/v202309/agentAlerts/{id}"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "GetAgentAlert"
      summary: "Get an agent alert configuration"
      description: "Retrieves an existing agent alert configuration."
    };
  }

  rpc ListAgentAlerts(ListAgentAlertsRequest) returns (ListAgentAlertsResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:read";
    option (kentik.core.v202303.method_permission) = "synthetics.agent::read";
    option (google.api.http) = {
      get: "/synthetics/v202309/agentAlerts"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "ListAgentAlerts"
      summary: "List agent alert configurations"
      description: "Lists all agent alert configurations, optionally filtered by a list of agent ids."
    };
  }

  rpc DeleteAgentAlert(DeleteAgentAlertRequest) returns (DeleteAgentAlertResponse) {
    option (kentik.core.v202303.method_scope) = "admin.synthetics:write";
    option (kentik.core.v202303.method_permission) = "synthetics.agent::delete";
    option (google.api.http) = {
      delete: "/synthetics/v202309/agentAlerts/{id}"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      operation_id: "DeleteAgentAlert"
      summary: "Delete an agent alert configuration"
      description: "Deletes an existing agent alert configuration."
    };
  }
}