All URIs are relative to http://localhost
| Method | HTTP request | Description |
|---|---|---|
| CountCloudAccounts | Post /toae/search/count/cloud-accounts | Count Cloud Nodes |
| CountCloudComplianceScans | Post /toae/search/count/cloud-compliance/scans | Count Cloud Compliance Scan results |
| CountCloudCompliances | Post /toae/search/count/cloud-compliances | Count Cloud compliances |
| CountCloudResources | Post /toae/search/count/cloud-resources | Count Cloud resources |
| CountComplianceRules | Post /toae/search/count/compliance-rules | Count Compliance Rules |
| CountComplianceScans | Post /toae/search/count/compliance/scans | Count Compliance Scan results |
| CountCompliances | Post /toae/search/count/compliances | Count Compliances |
| CountContainerImages | Post /toae/search/count/images | Count Container images |
| CountContainers | Post /toae/search/count/containers | Count Containers data |
| CountHosts | Post /toae/search/count/hosts | Count hosts |
| CountKubernetesClusters | Post /toae/search/count/kubernetes-clusters | Count Kubernetes clusters |
| CountMalwareRules | Post /toae/search/count/malware-rules | Count Malware Rules |
| CountMalwareScans | Post /toae/search/count/malware/scans | Count Malware Scan results |
| CountMalwares | Post /toae/search/count/malwares | Count Malwares |
| CountNodes | Get /toae/search/count/nodes | Count nodes |
| CountPods | Post /toae/search/count/pods | Count Pods |
| CountSecretRules | Post /toae/search/count/secret-rules | Count Secret Rules |
| CountSecrets | Post /toae/search/count/secrets | Count Secrets |
| CountSecretsScans | Post /toae/search/count/secret/scans | Count Secret Scan results |
| CountVulnerabilities | Post /toae/search/count/vulnerabilities | Count Vulnerabilities |
| CountVulnerabilityRules | Post /toae/search/count/vulnerability-rules | Count Vulnerability Rules |
| CountVulnerabilityScans | Post /toae/search/count/vulnerability/scans | Count Vulnerability Scan results |
| GetCloudComplianceFilters | Post /toae/filters/cloud-compliance | Get Cloud Compliance Filters |
| GetComplianceFilters | Post /toae/filters/compliance | Get Compliance Filters |
| SearchCloudAccounts | Post /toae/search/cloud-accounts | Search Cloud Nodes |
| SearchCloudComplianceScans | Post /toae/search/cloud-compliance/scans | Search Cloud Compliance Scan results |
| SearchCloudCompliances | Post /toae/search/cloud-compliances | Search Cloud compliances |
| SearchCloudResources | Post /toae/search/cloud-resources | Search Cloud Resources |
| SearchComplianceRules | Post /toae/search/compliance-rules | Search Compliance Rules |
| SearchComplianceScans | Post /toae/search/compliance/scans | Search Compliance Scan results |
| SearchCompliances | Post /toae/search/compliances | Search Compliances |
| SearchContainerImages | Post /toae/search/images | Search Container images |
| SearchContainers | Post /toae/search/containers | Search Containers data |
| SearchHosts | Post /toae/search/hosts | Search hosts |
| SearchKubernetesClusters | Post /toae/search/kubernetes-clusters | Search Kuberenetes Clusters |
| SearchMalwareRules | Post /toae/search/malware-rules | Search Malware Rules |
| SearchMalwareScans | Post /toae/search/malware/scans | Search Malware Scan results |
| SearchMalwares | Post /toae/search/malwares | Search Malwares |
| SearchPods | Post /toae/search/pods | Search Pods |
| SearchSecretRules | Post /toae/search/secret-rules | Search Secret Rules |
| SearchSecrets | Post /toae/search/secrets | Search Secrets |
| SearchSecretsScans | Post /toae/search/secret/scans | Search Secrets Scan results |
| SearchVulerabilityRules | Post /toae/search/vulnerability-rules | Search Vulnerability Rules |
| SearchVulnerabilities | Post /toae/search/vulnerabilities | Search Vulnerabilities |
| SearchVulnerabilityScans | Post /toae/search/vulnerability/scans | Search Vulnerability Scan results |
SearchSearchCountResp CountCloudAccounts(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Cloud Nodes
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountCloudAccounts(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountCloudAccounts``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountCloudAccounts`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountCloudAccounts`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountCloudAccountsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountCloudComplianceScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Count Cloud Compliance Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountCloudComplianceScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountCloudComplianceScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountCloudComplianceScans`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountCloudComplianceScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountCloudComplianceScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountCloudCompliances(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Cloud compliances
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountCloudCompliances(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountCloudCompliances``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountCloudCompliances`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountCloudCompliances`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountCloudCompliancesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountCloudResources(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Cloud resources
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountCloudResources(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountCloudResources``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountCloudResources`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountCloudResources`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountCloudResourcesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountComplianceRules(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Compliance Rules
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountComplianceRules(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountComplianceRules``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountComplianceRules`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountComplianceRules`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountComplianceRulesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountComplianceScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Count Compliance Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountComplianceScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountComplianceScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountComplianceScans`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountComplianceScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountComplianceScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountCompliances(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Compliances
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountCompliances(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountCompliances``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountCompliances`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountCompliances`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountCompliancesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountContainerImages(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Container images
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountContainerImages(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountContainerImages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountContainerImages`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountContainerImages`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountContainerImagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountContainers(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Containers data
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountContainers(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountContainers``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountContainers`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountContainers`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountContainersRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountHosts(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count hosts
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountHosts(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountHosts``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountHosts`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountHosts`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountHostsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountKubernetesClusters(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Kubernetes clusters
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountKubernetesClusters(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountKubernetesClusters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountKubernetesClusters`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountKubernetesClusters`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountKubernetesClustersRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountMalwareRules(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Malware Rules
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountMalwareRules(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountMalwareRules``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountMalwareRules`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountMalwareRules`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountMalwareRulesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountMalwareScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Count Malware Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountMalwareScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountMalwareScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountMalwareScans`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountMalwareScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountMalwareScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountMalwares(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Malwares
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountMalwares(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountMalwares``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountMalwares`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountMalwares`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountMalwaresRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchNodeCountResp CountNodes(ctx).Execute()
Count nodes
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountNodes(context.Background()).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountNodes``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountNodes`: SearchNodeCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountNodes`: %v\n", resp)
}This endpoint does not need any parameter.
Other parameters are passed through a pointer to a apiCountNodesRequest struct via the builder pattern
- Content-Type: Not defined
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountPods(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Pods
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountPods(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountPods``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountPods`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountPods`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountPodsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountSecretRules(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Secret Rules
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountSecretRules(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountSecretRules``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountSecretRules`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountSecretRules`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountSecretRulesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountSecrets(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Secrets
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountSecrets(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountSecrets``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountSecrets`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountSecrets`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountSecretsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountSecretsScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Count Secret Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountSecretsScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountSecretsScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountSecretsScans`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountSecretsScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountSecretsScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountVulnerabilities(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Vulnerabilities
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountVulnerabilities(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountVulnerabilities``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountVulnerabilities`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountVulnerabilities`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountVulnerabilitiesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountVulnerabilityRules(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Count Vulnerability Rules
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountVulnerabilityRules(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountVulnerabilityRules``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountVulnerabilityRules`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountVulnerabilityRules`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountVulnerabilityRulesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
SearchSearchCountResp CountVulnerabilityScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Count Vulnerability Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.CountVulnerabilityScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.CountVulnerabilityScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `CountVulnerabilityScans`: SearchSearchCountResp
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.CountVulnerabilityScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiCountVulnerabilityScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
ModelFiltersResult GetCloudComplianceFilters(ctx).ModelFiltersReq(modelFiltersReq).Execute()
Get Cloud Compliance Filters
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
modelFiltersReq := *openapiclient.NewModelFiltersReq([]string{"Filters_example"}) // ModelFiltersReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.GetCloudComplianceFilters(context.Background()).ModelFiltersReq(modelFiltersReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.GetCloudComplianceFilters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetCloudComplianceFilters`: ModelFiltersResult
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.GetCloudComplianceFilters`: %v\n", resp)
}Other parameters are passed through a pointer to a apiGetCloudComplianceFiltersRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| modelFiltersReq | ModelFiltersReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
ModelFiltersResult GetComplianceFilters(ctx).ModelFiltersReq(modelFiltersReq).Execute()
Get Compliance Filters
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
modelFiltersReq := *openapiclient.NewModelFiltersReq([]string{"Filters_example"}) // ModelFiltersReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.GetComplianceFilters(context.Background()).ModelFiltersReq(modelFiltersReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.GetComplianceFilters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `GetComplianceFilters`: ModelFiltersResult
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.GetComplianceFilters`: %v\n", resp)
}Other parameters are passed through a pointer to a apiGetComplianceFiltersRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| modelFiltersReq | ModelFiltersReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelCloudNodeAccountInfo SearchCloudAccounts(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Cloud Nodes
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchCloudAccounts(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchCloudAccounts``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchCloudAccounts`: []ModelCloudNodeAccountInfo
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchCloudAccounts`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchCloudAccountsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelScanInfo SearchCloudComplianceScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Search Cloud Compliance Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchCloudComplianceScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchCloudComplianceScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchCloudComplianceScans`: []ModelScanInfo
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchCloudComplianceScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchCloudComplianceScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelCloudCompliance SearchCloudCompliances(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Cloud compliances
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchCloudCompliances(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchCloudCompliances``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchCloudCompliances`: []ModelCloudCompliance
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchCloudCompliances`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchCloudCompliancesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelCloudResource SearchCloudResources(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Cloud Resources
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchCloudResources(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchCloudResources``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchCloudResources`: []ModelCloudResource
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchCloudResources`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchCloudResourcesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelComplianceRule SearchComplianceRules(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Compliance Rules
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchComplianceRules(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchComplianceRules``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchComplianceRules`: []ModelComplianceRule
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchComplianceRules`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchComplianceRulesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelScanInfo SearchComplianceScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Search Compliance Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchComplianceScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchComplianceScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchComplianceScans`: []ModelScanInfo
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchComplianceScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchComplianceScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelCompliance SearchCompliances(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Compliances
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchCompliances(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchCompliances``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchCompliances`: []ModelCompliance
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchCompliances`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchCompliancesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelContainerImage SearchContainerImages(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Container images
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchContainerImages(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchContainerImages``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchContainerImages`: []ModelContainerImage
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchContainerImages`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchContainerImagesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelContainer SearchContainers(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Containers data
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchContainers(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchContainers``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchContainers`: []ModelContainer
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchContainers`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchContainersRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelHost SearchHosts(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search hosts
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchHosts(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchHosts``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchHosts`: []ModelHost
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchHosts`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchHostsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelKubernetesCluster SearchKubernetesClusters(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Kuberenetes Clusters
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchKubernetesClusters(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchKubernetesClusters``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchKubernetesClusters`: []ModelKubernetesCluster
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchKubernetesClusters`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchKubernetesClustersRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelMalwareRule SearchMalwareRules(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Malware Rules
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchMalwareRules(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchMalwareRules``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchMalwareRules`: []ModelMalwareRule
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchMalwareRules`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchMalwareRulesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelScanInfo SearchMalwareScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Search Malware Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchMalwareScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchMalwareScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchMalwareScans`: []ModelScanInfo
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchMalwareScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchMalwareScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelMalware SearchMalwares(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Malwares
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchMalwares(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchMalwares``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchMalwares`: []ModelMalware
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchMalwares`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchMalwaresRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelPod SearchPods(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Pods
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchPods(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchPods``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchPods`: []ModelPod
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchPods`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchPodsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelSecretRule SearchSecretRules(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Secret Rules
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchSecretRules(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchSecretRules``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchSecretRules`: []ModelSecretRule
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchSecretRules`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchSecretRulesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelSecret SearchSecrets(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Secrets
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchSecrets(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchSecrets``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchSecrets`: []ModelSecret
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchSecrets`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchSecretsRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelScanInfo SearchSecretsScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Search Secrets Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchSecretsScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchSecretsScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchSecretsScans`: []ModelScanInfo
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchSecretsScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchSecretsScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelVulnerabilityRule SearchVulerabilityRules(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Vulnerability Rules
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchVulerabilityRules(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchVulerabilityRules``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchVulerabilityRules`: []ModelVulnerabilityRule
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchVulerabilityRules`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchVulerabilityRulesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelVulnerability SearchVulnerabilities(ctx).SearchSearchNodeReq(searchSearchNodeReq).Execute()
Search Vulnerabilities
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchNodeReq := *openapiclient.NewSearchSearchNodeReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchNodeReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchVulnerabilities(context.Background()).SearchSearchNodeReq(searchSearchNodeReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchVulnerabilities``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchVulnerabilities`: []ModelVulnerability
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchVulnerabilities`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchVulnerabilitiesRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchNodeReq | SearchSearchNodeReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]
[]ModelScanInfo SearchVulnerabilityScans(ctx).SearchSearchScanReq(searchSearchScanReq).Execute()
Search Vulnerability Scan results
package main
import (
"context"
"fmt"
"os"
openapiclient "github.com/Sam12121/golang_toae_sdk/client"
)
func main() {
searchSearchScanReq := *openapiclient.NewSearchSearchScanReq(*openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewSearchSearchFilter(*openapiclient.NewReportersFieldsFilters([]openapiclient.ReportersCompareFilter{*openapiclient.NewReportersCompareFilter("FieldName_example", interface{}(123), false)}, *openapiclient.NewReportersContainsFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersMatchFilter(map[string][]interface{}{"key": []interface{}{nil}}), *openapiclient.NewReportersOrderFilter([]openapiclient.ReportersOrderSpec{*openapiclient.NewReportersOrderSpec(false, "FieldName_example")})), []string{"InFieldFilter_example"}, *openapiclient.NewModelFetchWindow(int32(123), int32(123))), *openapiclient.NewModelFetchWindow(int32(123), int32(123))) // SearchSearchScanReq | (optional)
configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)
resp, r, err := apiClient.SearchAPI.SearchVulnerabilityScans(context.Background()).SearchSearchScanReq(searchSearchScanReq).Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `SearchAPI.SearchVulnerabilityScans``: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
// response from `SearchVulnerabilityScans`: []ModelScanInfo
fmt.Fprintf(os.Stdout, "Response from `SearchAPI.SearchVulnerabilityScans`: %v\n", resp)
}Other parameters are passed through a pointer to a apiSearchVulnerabilityScansRequest struct via the builder pattern
| Name | Type | Description | Notes |
|---|---|---|---|
| searchSearchScanReq | SearchSearchScanReq |
- Content-Type: application/json
- Accept: application/json
[Back to top] [Back to API list] [Back to Model list] [Back to README]