cdnv1

package

v0.6.0 Latest Latest Go to latest Published: Oct 21, 2024 License: Apache-2.0 Imports: 9 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/KscSDK/ksc-sdk-go

Links

Open Source Insights

Documentation ¶

Index ¶

Constants
type Cdnv1

Constants ¶

View Source

const (
	ServiceName = "cdn"       // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "cdn"       // ServiceID is a unique identifer of a specific service.
)

Service information constants

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Cdnv1 ¶

type Cdnv1 struct {
	*client.Client
}

Cdnv1 provides the API operation methods for making requests to cdnv1. See this package's package overview docs for details on the service.

Cdnv1 methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func ExtraNew ¶

func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Cdnv1

extraNew create int can support ssl or region locate set

func New ¶

func New(p client.ConfigProvider, cfgs ...*aws.Config) *Cdnv1

New creates a new instance of the Cdnv1 client with a session. If additional configuration is needed for the client instance use the optional ksc.Config parameter to add your extra config.

Example:

// Create a Cdnv1 client from just a session.
svc := cdnv1.New(mySession)

// Create a Cdnv1 client with additional configuration
svc := cdnv1.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func SdkNew ¶

func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Cdnv1

SdkNew create int can support ssl or region locate set

func (*Cdnv1) AddCdnDomainGet ¶

func (c *Cdnv1) AddCdnDomainGet(input *map[string]interface{}) (*map[string]interface{}, error)

AddCdnDomainGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation AddCdnDomainGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/AddCdnDomainGet

func (*Cdnv1) AddCdnDomainGetRequest ¶

func (c *Cdnv1) AddCdnDomainGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddCdnDomainGetRequest generates a "ksc/request.Request" representing the client's request for the AddCdnDomainGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddCdnDomainGet for more information on using the AddCdnDomainGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddCdnDomainGetRequest method.
req, resp := client.AddCdnDomainGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) AddCdnDomainGetWithContext ¶

func (c *Cdnv1) AddCdnDomainGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddCdnDomainGetWithContext is the same as AddCdnDomainGet with the addition of the ability to pass a context and additional request options.

See AddCdnDomainGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) AddCdnDomainPost ¶

func (c *Cdnv1) AddCdnDomainPost(input *map[string]interface{}) (*map[string]interface{}, error)

AddCdnDomainPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation AddCdnDomainPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/AddCdnDomainPost

func (*Cdnv1) AddCdnDomainPostRequest ¶

func (c *Cdnv1) AddCdnDomainPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddCdnDomainPostRequest generates a "ksc/request.Request" representing the client's request for the AddCdnDomainPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddCdnDomainPost for more information on using the AddCdnDomainPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddCdnDomainPostRequest method.
req, resp := client.AddCdnDomainPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) AddCdnDomainPostWithContext ¶

func (c *Cdnv1) AddCdnDomainPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddCdnDomainPostWithContext is the same as AddCdnDomainPost with the addition of the ability to pass a context and additional request options.

See AddCdnDomainPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) BlockDomainUrlPost ¶

func (c *Cdnv1) BlockDomainUrlPost(input *map[string]interface{}) (*map[string]interface{}, error)

BlockDomainUrlPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation BlockDomainUrlPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/BlockDomainUrlPost

func (*Cdnv1) BlockDomainUrlPostRequest ¶

func (c *Cdnv1) BlockDomainUrlPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

BlockDomainUrlPostRequest generates a "ksc/request.Request" representing the client's request for the BlockDomainUrlPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See BlockDomainUrlPost for more information on using the BlockDomainUrlPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the BlockDomainUrlPostRequest method.
req, resp := client.BlockDomainUrlPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) BlockDomainUrlPostWithContext ¶

func (c *Cdnv1) BlockDomainUrlPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

BlockDomainUrlPostWithContext is the same as BlockDomainUrlPost with the addition of the ability to pass a context and additional request options.

See BlockDomainUrlPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) ConfigCertificateGet ¶

func (c *Cdnv1) ConfigCertificateGet(input *map[string]interface{}) (*map[string]interface{}, error)

ConfigCertificateGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation ConfigCertificateGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/ConfigCertificateGet

func (*Cdnv1) ConfigCertificateGetRequest ¶

func (c *Cdnv1) ConfigCertificateGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ConfigCertificateGetRequest generates a "ksc/request.Request" representing the client's request for the ConfigCertificateGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ConfigCertificateGet for more information on using the ConfigCertificateGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ConfigCertificateGetRequest method.
req, resp := client.ConfigCertificateGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) ConfigCertificateGetWithContext ¶

func (c *Cdnv1) ConfigCertificateGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ConfigCertificateGetWithContext is the same as ConfigCertificateGet with the addition of the ability to pass a context and additional request options.

See ConfigCertificateGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) ConfigCertificatePost ¶

func (c *Cdnv1) ConfigCertificatePost(input *map[string]interface{}) (*map[string]interface{}, error)

ConfigCertificatePost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation ConfigCertificatePost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/ConfigCertificatePost

func (*Cdnv1) ConfigCertificatePostRequest ¶

func (c *Cdnv1) ConfigCertificatePostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ConfigCertificatePostRequest generates a "ksc/request.Request" representing the client's request for the ConfigCertificatePost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ConfigCertificatePost for more information on using the ConfigCertificatePost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ConfigCertificatePostRequest method.
req, resp := client.ConfigCertificatePostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) ConfigCertificatePostWithContext ¶

func (c *Cdnv1) ConfigCertificatePostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ConfigCertificatePostWithContext is the same as ConfigCertificatePost with the addition of the ability to pass a context and additional request options.

See ConfigCertificatePost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) DeleteCdnDomainGet ¶

func (c *Cdnv1) DeleteCdnDomainGet(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCdnDomainGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation DeleteCdnDomainGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/DeleteCdnDomainGet

func (*Cdnv1) DeleteCdnDomainGetRequest ¶

func (c *Cdnv1) DeleteCdnDomainGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteCdnDomainGetRequest generates a "ksc/request.Request" representing the client's request for the DeleteCdnDomainGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteCdnDomainGet for more information on using the DeleteCdnDomainGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteCdnDomainGetRequest method.
req, resp := client.DeleteCdnDomainGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) DeleteCdnDomainGetWithContext ¶

func (c *Cdnv1) DeleteCdnDomainGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteCdnDomainGetWithContext is the same as DeleteCdnDomainGet with the addition of the ability to pass a context and additional request options.

See DeleteCdnDomainGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) DeleteCdnDomainPost ¶

func (c *Cdnv1) DeleteCdnDomainPost(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCdnDomainPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation DeleteCdnDomainPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/DeleteCdnDomainPost

func (*Cdnv1) DeleteCdnDomainPostRequest ¶

func (c *Cdnv1) DeleteCdnDomainPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteCdnDomainPostRequest generates a "ksc/request.Request" representing the client's request for the DeleteCdnDomainPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteCdnDomainPost for more information on using the DeleteCdnDomainPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteCdnDomainPostRequest method.
req, resp := client.DeleteCdnDomainPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) DeleteCdnDomainPostWithContext ¶

func (c *Cdnv1) DeleteCdnDomainPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteCdnDomainPostWithContext is the same as DeleteCdnDomainPost with the addition of the ability to pass a context and additional request options.

See DeleteCdnDomainPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) DeleteHttpHeadersConfigGet ¶

func (c *Cdnv1) DeleteHttpHeadersConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteHttpHeadersConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation DeleteHttpHeadersConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/DeleteHttpHeadersConfigGet

func (*Cdnv1) DeleteHttpHeadersConfigGetRequest ¶

func (c *Cdnv1) DeleteHttpHeadersConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteHttpHeadersConfigGetRequest generates a "ksc/request.Request" representing the client's request for the DeleteHttpHeadersConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteHttpHeadersConfigGet for more information on using the DeleteHttpHeadersConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteHttpHeadersConfigGetRequest method.
req, resp := client.DeleteHttpHeadersConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) DeleteHttpHeadersConfigGetWithContext ¶

func (c *Cdnv1) DeleteHttpHeadersConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteHttpHeadersConfigGetWithContext is the same as DeleteHttpHeadersConfigGet with the addition of the ability to pass a context and additional request options.

See DeleteHttpHeadersConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) DeleteHttpHeadersConfigPost ¶

func (c *Cdnv1) DeleteHttpHeadersConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteHttpHeadersConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation DeleteHttpHeadersConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/DeleteHttpHeadersConfigPost

func (*Cdnv1) DeleteHttpHeadersConfigPostRequest ¶

func (c *Cdnv1) DeleteHttpHeadersConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteHttpHeadersConfigPostRequest generates a "ksc/request.Request" representing the client's request for the DeleteHttpHeadersConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteHttpHeadersConfigPost for more information on using the DeleteHttpHeadersConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteHttpHeadersConfigPostRequest method.
req, resp := client.DeleteHttpHeadersConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) DeleteHttpHeadersConfigPostWithContext ¶

func (c *Cdnv1) DeleteHttpHeadersConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteHttpHeadersConfigPostWithContext is the same as DeleteHttpHeadersConfigPost with the addition of the ability to pass a context and additional request options.

See DeleteHttpHeadersConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetAreaDataGet ¶

func (c *Cdnv1) GetAreaDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetAreaDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetAreaDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetAreaDataGet

func (*Cdnv1) GetAreaDataGetRequest ¶

func (c *Cdnv1) GetAreaDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAreaDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetAreaDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAreaDataGet for more information on using the GetAreaDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAreaDataGetRequest method.
req, resp := client.GetAreaDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetAreaDataGetWithContext ¶

func (c *Cdnv1) GetAreaDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAreaDataGetWithContext is the same as GetAreaDataGet with the addition of the ability to pass a context and additional request options.

See GetAreaDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetAreaDataPost ¶

func (c *Cdnv1) GetAreaDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetAreaDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetAreaDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetAreaDataPost

func (*Cdnv1) GetAreaDataPostRequest ¶

func (c *Cdnv1) GetAreaDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAreaDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetAreaDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAreaDataPost for more information on using the GetAreaDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAreaDataPostRequest method.
req, resp := client.GetAreaDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetAreaDataPostWithContext ¶

func (c *Cdnv1) GetAreaDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAreaDataPostWithContext is the same as GetAreaDataPost with the addition of the ability to pass a context and additional request options.

See GetAreaDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBandwidthDataByDirGet ¶

func (c *Cdnv1) GetBandwidthDataByDirGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetBandwidthDataByDirGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBandwidthDataByDirGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBandwidthDataByDirGet

func (*Cdnv1) GetBandwidthDataByDirGetRequest ¶

func (c *Cdnv1) GetBandwidthDataByDirGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBandwidthDataByDirGetRequest generates a "ksc/request.Request" representing the client's request for the GetBandwidthDataByDirGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBandwidthDataByDirGet for more information on using the GetBandwidthDataByDirGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBandwidthDataByDirGetRequest method.
req, resp := client.GetBandwidthDataByDirGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBandwidthDataByDirGetWithContext ¶

func (c *Cdnv1) GetBandwidthDataByDirGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBandwidthDataByDirGetWithContext is the same as GetBandwidthDataByDirGet with the addition of the ability to pass a context and additional request options.

See GetBandwidthDataByDirGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBandwidthDataByDirPost ¶

func (c *Cdnv1) GetBandwidthDataByDirPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetBandwidthDataByDirPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBandwidthDataByDirPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBandwidthDataByDirPost

func (*Cdnv1) GetBandwidthDataByDirPostRequest ¶

func (c *Cdnv1) GetBandwidthDataByDirPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBandwidthDataByDirPostRequest generates a "ksc/request.Request" representing the client's request for the GetBandwidthDataByDirPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBandwidthDataByDirPost for more information on using the GetBandwidthDataByDirPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBandwidthDataByDirPostRequest method.
req, resp := client.GetBandwidthDataByDirPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBandwidthDataByDirPostWithContext ¶

func (c *Cdnv1) GetBandwidthDataByDirPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBandwidthDataByDirPostWithContext is the same as GetBandwidthDataByDirPost with the addition of the ability to pass a context and additional request options.

See GetBandwidthDataByDirPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBandwidthDataGet ¶

func (c *Cdnv1) GetBandwidthDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetBandwidthDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBandwidthDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBandwidthDataGet

func (*Cdnv1) GetBandwidthDataGetRequest ¶

func (c *Cdnv1) GetBandwidthDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBandwidthDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetBandwidthDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBandwidthDataGet for more information on using the GetBandwidthDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBandwidthDataGetRequest method.
req, resp := client.GetBandwidthDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBandwidthDataGetWithContext ¶

func (c *Cdnv1) GetBandwidthDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBandwidthDataGetWithContext is the same as GetBandwidthDataGet with the addition of the ability to pass a context and additional request options.

See GetBandwidthDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBandwidthDataPost ¶

func (c *Cdnv1) GetBandwidthDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetBandwidthDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBandwidthDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBandwidthDataPost

func (*Cdnv1) GetBandwidthDataPostRequest ¶

func (c *Cdnv1) GetBandwidthDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBandwidthDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetBandwidthDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBandwidthDataPost for more information on using the GetBandwidthDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBandwidthDataPostRequest method.
req, resp := client.GetBandwidthDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBandwidthDataPostWithContext ¶

func (c *Cdnv1) GetBandwidthDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBandwidthDataPostWithContext is the same as GetBandwidthDataPost with the addition of the ability to pass a context and additional request options.

See GetBandwidthDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBillingDataGet ¶

func (c *Cdnv1) GetBillingDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetBillingDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBillingDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBillingDataGet

func (*Cdnv1) GetBillingDataGetRequest ¶

func (c *Cdnv1) GetBillingDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBillingDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetBillingDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBillingDataGet for more information on using the GetBillingDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBillingDataGetRequest method.
req, resp := client.GetBillingDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBillingDataGetWithContext ¶

func (c *Cdnv1) GetBillingDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBillingDataGetWithContext is the same as GetBillingDataGet with the addition of the ability to pass a context and additional request options.

See GetBillingDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBillingDataPost ¶

func (c *Cdnv1) GetBillingDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetBillingDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBillingDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBillingDataPost

func (*Cdnv1) GetBillingDataPostRequest ¶

func (c *Cdnv1) GetBillingDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBillingDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetBillingDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBillingDataPost for more information on using the GetBillingDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBillingDataPostRequest method.
req, resp := client.GetBillingDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBillingDataPostWithContext ¶

func (c *Cdnv1) GetBillingDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBillingDataPostWithContext is the same as GetBillingDataPost with the addition of the ability to pass a context and additional request options.

See GetBillingDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBillingModeGet ¶

func (c *Cdnv1) GetBillingModeGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetBillingModeGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBillingModeGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBillingModeGet

func (*Cdnv1) GetBillingModeGetRequest ¶

func (c *Cdnv1) GetBillingModeGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBillingModeGetRequest generates a "ksc/request.Request" representing the client's request for the GetBillingModeGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBillingModeGet for more information on using the GetBillingModeGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBillingModeGetRequest method.
req, resp := client.GetBillingModeGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBillingModeGetWithContext ¶

func (c *Cdnv1) GetBillingModeGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBillingModeGetWithContext is the same as GetBillingModeGet with the addition of the ability to pass a context and additional request options.

See GetBillingModeGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBillingModePost ¶

func (c *Cdnv1) GetBillingModePost(input *map[string]interface{}) (*map[string]interface{}, error)

GetBillingModePost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBillingModePost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBillingModePost

func (*Cdnv1) GetBillingModePostRequest ¶

func (c *Cdnv1) GetBillingModePostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBillingModePostRequest generates a "ksc/request.Request" representing the client's request for the GetBillingModePost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBillingModePost for more information on using the GetBillingModePost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBillingModePostRequest method.
req, resp := client.GetBillingModePostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBillingModePostWithContext ¶

func (c *Cdnv1) GetBillingModePostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBillingModePostWithContext is the same as GetBillingModePost with the addition of the ability to pass a context and additional request options.

See GetBillingModePost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBlockUrlQuotaGet ¶

func (c *Cdnv1) GetBlockUrlQuotaGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetBlockUrlQuotaGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBlockUrlQuotaGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBlockUrlQuotaGet

func (*Cdnv1) GetBlockUrlQuotaGetRequest ¶

func (c *Cdnv1) GetBlockUrlQuotaGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBlockUrlQuotaGetRequest generates a "ksc/request.Request" representing the client's request for the GetBlockUrlQuotaGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBlockUrlQuotaGet for more information on using the GetBlockUrlQuotaGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBlockUrlQuotaGetRequest method.
req, resp := client.GetBlockUrlQuotaGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBlockUrlQuotaGetWithContext ¶

func (c *Cdnv1) GetBlockUrlQuotaGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBlockUrlQuotaGetWithContext is the same as GetBlockUrlQuotaGet with the addition of the ability to pass a context and additional request options.

See GetBlockUrlQuotaGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBlockUrlQuotaPost ¶

func (c *Cdnv1) GetBlockUrlQuotaPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetBlockUrlQuotaPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBlockUrlQuotaPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBlockUrlQuotaPost

func (*Cdnv1) GetBlockUrlQuotaPostRequest ¶

func (c *Cdnv1) GetBlockUrlQuotaPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBlockUrlQuotaPostRequest generates a "ksc/request.Request" representing the client's request for the GetBlockUrlQuotaPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBlockUrlQuotaPost for more information on using the GetBlockUrlQuotaPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBlockUrlQuotaPostRequest method.
req, resp := client.GetBlockUrlQuotaPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBlockUrlQuotaPostWithContext ¶

func (c *Cdnv1) GetBlockUrlQuotaPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBlockUrlQuotaPostWithContext is the same as GetBlockUrlQuotaPost with the addition of the ability to pass a context and additional request options.

See GetBlockUrlQuotaPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetBlockUrlTaskPost ¶

func (c *Cdnv1) GetBlockUrlTaskPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetBlockUrlTaskPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetBlockUrlTaskPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetBlockUrlTaskPost

func (*Cdnv1) GetBlockUrlTaskPostRequest ¶

func (c *Cdnv1) GetBlockUrlTaskPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetBlockUrlTaskPostRequest generates a "ksc/request.Request" representing the client's request for the GetBlockUrlTaskPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetBlockUrlTaskPost for more information on using the GetBlockUrlTaskPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetBlockUrlTaskPostRequest method.
req, resp := client.GetBlockUrlTaskPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetBlockUrlTaskPostWithContext ¶

func (c *Cdnv1) GetBlockUrlTaskPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetBlockUrlTaskPostWithContext is the same as GetBlockUrlTaskPost with the addition of the ability to pass a context and additional request options.

See GetBlockUrlTaskPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetCdnDomainBasicInfoGet ¶

func (c *Cdnv1) GetCdnDomainBasicInfoGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetCdnDomainBasicInfoGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetCdnDomainBasicInfoGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetCdnDomainBasicInfoGet

func (*Cdnv1) GetCdnDomainBasicInfoGetRequest ¶

func (c *Cdnv1) GetCdnDomainBasicInfoGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetCdnDomainBasicInfoGetRequest generates a "ksc/request.Request" representing the client's request for the GetCdnDomainBasicInfoGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetCdnDomainBasicInfoGet for more information on using the GetCdnDomainBasicInfoGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetCdnDomainBasicInfoGetRequest method.
req, resp := client.GetCdnDomainBasicInfoGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetCdnDomainBasicInfoGetWithContext ¶

func (c *Cdnv1) GetCdnDomainBasicInfoGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetCdnDomainBasicInfoGetWithContext is the same as GetCdnDomainBasicInfoGet with the addition of the ability to pass a context and additional request options.

See GetCdnDomainBasicInfoGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetCdnDomainBasicInfoPost ¶

func (c *Cdnv1) GetCdnDomainBasicInfoPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetCdnDomainBasicInfoPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetCdnDomainBasicInfoPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetCdnDomainBasicInfoPost

func (*Cdnv1) GetCdnDomainBasicInfoPostRequest ¶

func (c *Cdnv1) GetCdnDomainBasicInfoPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetCdnDomainBasicInfoPostRequest generates a "ksc/request.Request" representing the client's request for the GetCdnDomainBasicInfoPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetCdnDomainBasicInfoPost for more information on using the GetCdnDomainBasicInfoPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetCdnDomainBasicInfoPostRequest method.
req, resp := client.GetCdnDomainBasicInfoPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetCdnDomainBasicInfoPostWithContext ¶

func (c *Cdnv1) GetCdnDomainBasicInfoPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetCdnDomainBasicInfoPostWithContext is the same as GetCdnDomainBasicInfoPost with the addition of the ability to pass a context and additional request options.

See GetCdnDomainBasicInfoPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetCdnDomainsGet ¶

func (c *Cdnv1) GetCdnDomainsGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetCdnDomainsGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetCdnDomainsGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetCdnDomainsGet

func (*Cdnv1) GetCdnDomainsGetRequest ¶

func (c *Cdnv1) GetCdnDomainsGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetCdnDomainsGetRequest generates a "ksc/request.Request" representing the client's request for the GetCdnDomainsGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetCdnDomainsGet for more information on using the GetCdnDomainsGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetCdnDomainsGetRequest method.
req, resp := client.GetCdnDomainsGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetCdnDomainsGetWithContext ¶

func (c *Cdnv1) GetCdnDomainsGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetCdnDomainsGetWithContext is the same as GetCdnDomainsGet with the addition of the ability to pass a context and additional request options.

See GetCdnDomainsGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetCdnDomainsPost ¶

func (c *Cdnv1) GetCdnDomainsPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetCdnDomainsPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetCdnDomainsPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetCdnDomainsPost

func (*Cdnv1) GetCdnDomainsPostRequest ¶

func (c *Cdnv1) GetCdnDomainsPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetCdnDomainsPostRequest generates a "ksc/request.Request" representing the client's request for the GetCdnDomainsPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetCdnDomainsPost for more information on using the GetCdnDomainsPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetCdnDomainsPostRequest method.
req, resp := client.GetCdnDomainsPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetCdnDomainsPostWithContext ¶

func (c *Cdnv1) GetCdnDomainsPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetCdnDomainsPostWithContext is the same as GetCdnDomainsPost with the addition of the ability to pass a context and additional request options.

See GetCdnDomainsPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetCertificatesGet ¶

func (c *Cdnv1) GetCertificatesGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetCertificatesGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetCertificatesGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetCertificatesGet

func (*Cdnv1) GetCertificatesGetRequest ¶

func (c *Cdnv1) GetCertificatesGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetCertificatesGetRequest generates a "ksc/request.Request" representing the client's request for the GetCertificatesGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetCertificatesGet for more information on using the GetCertificatesGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetCertificatesGetRequest method.
req, resp := client.GetCertificatesGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetCertificatesGetWithContext ¶

func (c *Cdnv1) GetCertificatesGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetCertificatesGetWithContext is the same as GetCertificatesGet with the addition of the ability to pass a context and additional request options.

See GetCertificatesGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetCertificatesPost ¶

func (c *Cdnv1) GetCertificatesPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetCertificatesPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetCertificatesPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetCertificatesPost

func (*Cdnv1) GetCertificatesPostRequest ¶

func (c *Cdnv1) GetCertificatesPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetCertificatesPostRequest generates a "ksc/request.Request" representing the client's request for the GetCertificatesPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetCertificatesPost for more information on using the GetCertificatesPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetCertificatesPostRequest method.
req, resp := client.GetCertificatesPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetCertificatesPostWithContext ¶

func (c *Cdnv1) GetCertificatesPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetCertificatesPostWithContext is the same as GetCertificatesPost with the addition of the ability to pass a context and additional request options.

See GetCertificatesPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetCnameSuffixsGet ¶

func (c *Cdnv1) GetCnameSuffixsGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetCnameSuffixsGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetCnameSuffixsGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetCnameSuffixsGet

func (*Cdnv1) GetCnameSuffixsGetRequest ¶

func (c *Cdnv1) GetCnameSuffixsGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetCnameSuffixsGetRequest generates a "ksc/request.Request" representing the client's request for the GetCnameSuffixsGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetCnameSuffixsGet for more information on using the GetCnameSuffixsGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetCnameSuffixsGetRequest method.
req, resp := client.GetCnameSuffixsGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetCnameSuffixsGetWithContext ¶

func (c *Cdnv1) GetCnameSuffixsGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetCnameSuffixsGetWithContext is the same as GetCnameSuffixsGet with the addition of the ability to pass a context and additional request options.

See GetCnameSuffixsGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetDomainConfigsGet ¶

func (c *Cdnv1) GetDomainConfigsGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetDomainConfigsGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetDomainConfigsGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetDomainConfigsGet

func (*Cdnv1) GetDomainConfigsGetRequest ¶

func (c *Cdnv1) GetDomainConfigsGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetDomainConfigsGetRequest generates a "ksc/request.Request" representing the client's request for the GetDomainConfigsGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetDomainConfigsGet for more information on using the GetDomainConfigsGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetDomainConfigsGetRequest method.
req, resp := client.GetDomainConfigsGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetDomainConfigsGetWithContext ¶

func (c *Cdnv1) GetDomainConfigsGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetDomainConfigsGetWithContext is the same as GetDomainConfigsGet with the addition of the ability to pass a context and additional request options.

See GetDomainConfigsGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetDomainConfigsPost ¶

func (c *Cdnv1) GetDomainConfigsPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetDomainConfigsPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetDomainConfigsPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetDomainConfigsPost

func (*Cdnv1) GetDomainConfigsPostRequest ¶

func (c *Cdnv1) GetDomainConfigsPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetDomainConfigsPostRequest generates a "ksc/request.Request" representing the client's request for the GetDomainConfigsPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetDomainConfigsPost for more information on using the GetDomainConfigsPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetDomainConfigsPostRequest method.
req, resp := client.GetDomainConfigsPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetDomainConfigsPostWithContext ¶

func (c *Cdnv1) GetDomainConfigsPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetDomainConfigsPostWithContext is the same as GetDomainConfigsPost with the addition of the ability to pass a context and additional request options.

See GetDomainConfigsPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetDomainLogServiceStatusGet ¶

func (c *Cdnv1) GetDomainLogServiceStatusGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetDomainLogServiceStatusGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetDomainLogServiceStatusGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetDomainLogServiceStatusGet

func (*Cdnv1) GetDomainLogServiceStatusGetRequest ¶

func (c *Cdnv1) GetDomainLogServiceStatusGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetDomainLogServiceStatusGetRequest generates a "ksc/request.Request" representing the client's request for the GetDomainLogServiceStatusGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetDomainLogServiceStatusGet for more information on using the GetDomainLogServiceStatusGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetDomainLogServiceStatusGetRequest method.
req, resp := client.GetDomainLogServiceStatusGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetDomainLogServiceStatusGetWithContext ¶

func (c *Cdnv1) GetDomainLogServiceStatusGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetDomainLogServiceStatusGetWithContext is the same as GetDomainLogServiceStatusGet with the addition of the ability to pass a context and additional request options.

See GetDomainLogServiceStatusGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetDomainLogServiceStatusPost ¶

func (c *Cdnv1) GetDomainLogServiceStatusPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetDomainLogServiceStatusPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetDomainLogServiceStatusPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetDomainLogServiceStatusPost

func (*Cdnv1) GetDomainLogServiceStatusPostRequest ¶

func (c *Cdnv1) GetDomainLogServiceStatusPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetDomainLogServiceStatusPostRequest generates a "ksc/request.Request" representing the client's request for the GetDomainLogServiceStatusPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetDomainLogServiceStatusPost for more information on using the GetDomainLogServiceStatusPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetDomainLogServiceStatusPostRequest method.
req, resp := client.GetDomainLogServiceStatusPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetDomainLogServiceStatusPostWithContext ¶

func (c *Cdnv1) GetDomainLogServiceStatusPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetDomainLogServiceStatusPostWithContext is the same as GetDomainLogServiceStatusPost with the addition of the ability to pass a context and additional request options.

See GetDomainLogServiceStatusPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetDomainLogsGet ¶

func (c *Cdnv1) GetDomainLogsGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetDomainLogsGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetDomainLogsGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetDomainLogsGet

func (*Cdnv1) GetDomainLogsGetRequest ¶

func (c *Cdnv1) GetDomainLogsGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetDomainLogsGetRequest generates a "ksc/request.Request" representing the client's request for the GetDomainLogsGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetDomainLogsGet for more information on using the GetDomainLogsGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetDomainLogsGetRequest method.
req, resp := client.GetDomainLogsGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetDomainLogsGetWithContext ¶

func (c *Cdnv1) GetDomainLogsGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetDomainLogsGetWithContext is the same as GetDomainLogsGet with the addition of the ability to pass a context and additional request options.

See GetDomainLogsGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetDomainLogsPost ¶

func (c *Cdnv1) GetDomainLogsPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetDomainLogsPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetDomainLogsPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetDomainLogsPost

func (*Cdnv1) GetDomainLogsPostRequest ¶

func (c *Cdnv1) GetDomainLogsPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetDomainLogsPostRequest generates a "ksc/request.Request" representing the client's request for the GetDomainLogsPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetDomainLogsPost for more information on using the GetDomainLogsPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetDomainLogsPostRequest method.
req, resp := client.GetDomainLogsPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetDomainLogsPostWithContext ¶

func (c *Cdnv1) GetDomainLogsPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetDomainLogsPostWithContext is the same as GetDomainLogsPost with the addition of the ability to pass a context and additional request options.

See GetDomainLogsPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetDomainRankingListDataGet ¶

func (c *Cdnv1) GetDomainRankingListDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetDomainRankingListDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetDomainRankingListDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetDomainRankingListDataGet

func (*Cdnv1) GetDomainRankingListDataGetRequest ¶

func (c *Cdnv1) GetDomainRankingListDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetDomainRankingListDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetDomainRankingListDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetDomainRankingListDataGet for more information on using the GetDomainRankingListDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetDomainRankingListDataGetRequest method.
req, resp := client.GetDomainRankingListDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetDomainRankingListDataGetWithContext ¶

func (c *Cdnv1) GetDomainRankingListDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetDomainRankingListDataGetWithContext is the same as GetDomainRankingListDataGet with the addition of the ability to pass a context and additional request options.

See GetDomainRankingListDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetDomainRankingListDataPost ¶

func (c *Cdnv1) GetDomainRankingListDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetDomainRankingListDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetDomainRankingListDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetDomainRankingListDataPost

func (*Cdnv1) GetDomainRankingListDataPostRequest ¶

func (c *Cdnv1) GetDomainRankingListDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetDomainRankingListDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetDomainRankingListDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetDomainRankingListDataPost for more information on using the GetDomainRankingListDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetDomainRankingListDataPostRequest method.
req, resp := client.GetDomainRankingListDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetDomainRankingListDataPostWithContext ¶

func (c *Cdnv1) GetDomainRankingListDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetDomainRankingListDataPostWithContext is the same as GetDomainRankingListDataPost with the addition of the ability to pass a context and additional request options.

See GetDomainRankingListDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetDomainsByOriginGet ¶

func (c *Cdnv1) GetDomainsByOriginGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetDomainsByOriginGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetDomainsByOriginGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetDomainsByOriginGet

func (*Cdnv1) GetDomainsByOriginGetRequest ¶

func (c *Cdnv1) GetDomainsByOriginGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetDomainsByOriginGetRequest generates a "ksc/request.Request" representing the client's request for the GetDomainsByOriginGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetDomainsByOriginGet for more information on using the GetDomainsByOriginGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetDomainsByOriginGetRequest method.
req, resp := client.GetDomainsByOriginGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetDomainsByOriginGetWithContext ¶

func (c *Cdnv1) GetDomainsByOriginGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetDomainsByOriginGetWithContext is the same as GetDomainsByOriginGet with the addition of the ability to pass a context and additional request options.

See GetDomainsByOriginGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetFlowDataByDirGet ¶

func (c *Cdnv1) GetFlowDataByDirGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetFlowDataByDirGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetFlowDataByDirGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetFlowDataByDirGet

func (*Cdnv1) GetFlowDataByDirGetRequest ¶

func (c *Cdnv1) GetFlowDataByDirGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetFlowDataByDirGetRequest generates a "ksc/request.Request" representing the client's request for the GetFlowDataByDirGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetFlowDataByDirGet for more information on using the GetFlowDataByDirGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetFlowDataByDirGetRequest method.
req, resp := client.GetFlowDataByDirGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetFlowDataByDirGetWithContext ¶

func (c *Cdnv1) GetFlowDataByDirGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetFlowDataByDirGetWithContext is the same as GetFlowDataByDirGet with the addition of the ability to pass a context and additional request options.

See GetFlowDataByDirGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetFlowDataByDirPost ¶

func (c *Cdnv1) GetFlowDataByDirPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetFlowDataByDirPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetFlowDataByDirPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetFlowDataByDirPost

func (*Cdnv1) GetFlowDataByDirPostRequest ¶

func (c *Cdnv1) GetFlowDataByDirPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetFlowDataByDirPostRequest generates a "ksc/request.Request" representing the client's request for the GetFlowDataByDirPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetFlowDataByDirPost for more information on using the GetFlowDataByDirPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetFlowDataByDirPostRequest method.
req, resp := client.GetFlowDataByDirPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetFlowDataByDirPostWithContext ¶

func (c *Cdnv1) GetFlowDataByDirPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetFlowDataByDirPostWithContext is the same as GetFlowDataByDirPost with the addition of the ability to pass a context and additional request options.

See GetFlowDataByDirPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetFlowDataGet ¶

func (c *Cdnv1) GetFlowDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetFlowDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetFlowDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetFlowDataGet

func (*Cdnv1) GetFlowDataGetRequest ¶

func (c *Cdnv1) GetFlowDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetFlowDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetFlowDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetFlowDataGet for more information on using the GetFlowDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetFlowDataGetRequest method.
req, resp := client.GetFlowDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetFlowDataGetWithContext ¶

func (c *Cdnv1) GetFlowDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetFlowDataGetWithContext is the same as GetFlowDataGet with the addition of the ability to pass a context and additional request options.

See GetFlowDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetFlowDataPost ¶

func (c *Cdnv1) GetFlowDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetFlowDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetFlowDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetFlowDataPost

func (*Cdnv1) GetFlowDataPostRequest ¶

func (c *Cdnv1) GetFlowDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetFlowDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetFlowDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetFlowDataPost for more information on using the GetFlowDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetFlowDataPostRequest method.
req, resp := client.GetFlowDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetFlowDataPostWithContext ¶

func (c *Cdnv1) GetFlowDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetFlowDataPostWithContext is the same as GetFlowDataPost with the addition of the ability to pass a context and additional request options.

See GetFlowDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHitRateDataGet ¶

func (c *Cdnv1) GetHitRateDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetHitRateDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHitRateDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHitRateDataGet

func (*Cdnv1) GetHitRateDataGetRequest ¶

func (c *Cdnv1) GetHitRateDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHitRateDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetHitRateDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHitRateDataGet for more information on using the GetHitRateDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHitRateDataGetRequest method.
req, resp := client.GetHitRateDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHitRateDataGetWithContext ¶

func (c *Cdnv1) GetHitRateDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHitRateDataGetWithContext is the same as GetHitRateDataGet with the addition of the ability to pass a context and additional request options.

See GetHitRateDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHitRateDataPost ¶

func (c *Cdnv1) GetHitRateDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetHitRateDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHitRateDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHitRateDataPost

func (*Cdnv1) GetHitRateDataPostRequest ¶

func (c *Cdnv1) GetHitRateDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHitRateDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetHitRateDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHitRateDataPost for more information on using the GetHitRateDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHitRateDataPostRequest method.
req, resp := client.GetHitRateDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHitRateDataPostWithContext ¶

func (c *Cdnv1) GetHitRateDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHitRateDataPostWithContext is the same as GetHitRateDataPost with the addition of the ability to pass a context and additional request options.

See GetHitRateDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHitRateDetailedDataGet ¶

func (c *Cdnv1) GetHitRateDetailedDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetHitRateDetailedDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHitRateDetailedDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHitRateDetailedDataGet

func (*Cdnv1) GetHitRateDetailedDataGetRequest ¶

func (c *Cdnv1) GetHitRateDetailedDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHitRateDetailedDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetHitRateDetailedDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHitRateDetailedDataGet for more information on using the GetHitRateDetailedDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHitRateDetailedDataGetRequest method.
req, resp := client.GetHitRateDetailedDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHitRateDetailedDataGetWithContext ¶

func (c *Cdnv1) GetHitRateDetailedDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHitRateDetailedDataGetWithContext is the same as GetHitRateDetailedDataGet with the addition of the ability to pass a context and additional request options.

See GetHitRateDetailedDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHitRateDetailedDataPost ¶

func (c *Cdnv1) GetHitRateDetailedDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetHitRateDetailedDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHitRateDetailedDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHitRateDetailedDataPost

func (*Cdnv1) GetHitRateDetailedDataPostRequest ¶

func (c *Cdnv1) GetHitRateDetailedDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHitRateDetailedDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetHitRateDetailedDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHitRateDetailedDataPost for more information on using the GetHitRateDetailedDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHitRateDetailedDataPostRequest method.
req, resp := client.GetHitRateDetailedDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHitRateDetailedDataPostWithContext ¶

func (c *Cdnv1) GetHitRateDetailedDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHitRateDetailedDataPostWithContext is the same as GetHitRateDetailedDataPost with the addition of the ability to pass a context and additional request options.

See GetHitRateDetailedDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHttpCodeDataGet ¶

func (c *Cdnv1) GetHttpCodeDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetHttpCodeDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHttpCodeDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHttpCodeDataGet

func (*Cdnv1) GetHttpCodeDataGetRequest ¶

func (c *Cdnv1) GetHttpCodeDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHttpCodeDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetHttpCodeDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHttpCodeDataGet for more information on using the GetHttpCodeDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHttpCodeDataGetRequest method.
req, resp := client.GetHttpCodeDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHttpCodeDataGetWithContext ¶

func (c *Cdnv1) GetHttpCodeDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHttpCodeDataGetWithContext is the same as GetHttpCodeDataGet with the addition of the ability to pass a context and additional request options.

See GetHttpCodeDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHttpCodeDataPost ¶

func (c *Cdnv1) GetHttpCodeDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetHttpCodeDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHttpCodeDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHttpCodeDataPost

func (*Cdnv1) GetHttpCodeDataPostRequest ¶

func (c *Cdnv1) GetHttpCodeDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHttpCodeDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetHttpCodeDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHttpCodeDataPost for more information on using the GetHttpCodeDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHttpCodeDataPostRequest method.
req, resp := client.GetHttpCodeDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHttpCodeDataPostWithContext ¶

func (c *Cdnv1) GetHttpCodeDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHttpCodeDataPostWithContext is the same as GetHttpCodeDataPost with the addition of the ability to pass a context and additional request options.

See GetHttpCodeDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHttpCodeDetailedDataGet ¶

func (c *Cdnv1) GetHttpCodeDetailedDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetHttpCodeDetailedDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHttpCodeDetailedDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHttpCodeDetailedDataGet

func (*Cdnv1) GetHttpCodeDetailedDataGetRequest ¶

func (c *Cdnv1) GetHttpCodeDetailedDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHttpCodeDetailedDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetHttpCodeDetailedDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHttpCodeDetailedDataGet for more information on using the GetHttpCodeDetailedDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHttpCodeDetailedDataGetRequest method.
req, resp := client.GetHttpCodeDetailedDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHttpCodeDetailedDataGetWithContext ¶

func (c *Cdnv1) GetHttpCodeDetailedDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHttpCodeDetailedDataGetWithContext is the same as GetHttpCodeDetailedDataGet with the addition of the ability to pass a context and additional request options.

See GetHttpCodeDetailedDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHttpCodeDetailedDataPost ¶

func (c *Cdnv1) GetHttpCodeDetailedDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetHttpCodeDetailedDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHttpCodeDetailedDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHttpCodeDetailedDataPost

func (*Cdnv1) GetHttpCodeDetailedDataPostRequest ¶

func (c *Cdnv1) GetHttpCodeDetailedDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHttpCodeDetailedDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetHttpCodeDetailedDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHttpCodeDetailedDataPost for more information on using the GetHttpCodeDetailedDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHttpCodeDetailedDataPostRequest method.
req, resp := client.GetHttpCodeDetailedDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHttpCodeDetailedDataPostWithContext ¶

func (c *Cdnv1) GetHttpCodeDetailedDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHttpCodeDetailedDataPostWithContext is the same as GetHttpCodeDetailedDataPost with the addition of the ability to pass a context and additional request options.

See GetHttpCodeDetailedDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHttpHeaderListGet ¶

func (c *Cdnv1) GetHttpHeaderListGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetHttpHeaderListGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHttpHeaderListGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHttpHeaderListGet

func (*Cdnv1) GetHttpHeaderListGetRequest ¶

func (c *Cdnv1) GetHttpHeaderListGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHttpHeaderListGetRequest generates a "ksc/request.Request" representing the client's request for the GetHttpHeaderListGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHttpHeaderListGet for more information on using the GetHttpHeaderListGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHttpHeaderListGetRequest method.
req, resp := client.GetHttpHeaderListGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHttpHeaderListGetWithContext ¶

func (c *Cdnv1) GetHttpHeaderListGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHttpHeaderListGetWithContext is the same as GetHttpHeaderListGet with the addition of the ability to pass a context and additional request options.

See GetHttpHeaderListGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetHttpHeaderListPost ¶

func (c *Cdnv1) GetHttpHeaderListPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetHttpHeaderListPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetHttpHeaderListPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetHttpHeaderListPost

func (*Cdnv1) GetHttpHeaderListPostRequest ¶

func (c *Cdnv1) GetHttpHeaderListPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetHttpHeaderListPostRequest generates a "ksc/request.Request" representing the client's request for the GetHttpHeaderListPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetHttpHeaderListPost for more information on using the GetHttpHeaderListPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetHttpHeaderListPostRequest method.
req, resp := client.GetHttpHeaderListPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetHttpHeaderListPostWithContext ¶

func (c *Cdnv1) GetHttpHeaderListPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetHttpHeaderListPostWithContext is the same as GetHttpHeaderListPost with the addition of the ability to pass a context and additional request options.

See GetHttpHeaderListPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetIspDataGet ¶

func (c *Cdnv1) GetIspDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetIspDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetIspDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetIspDataGet

func (*Cdnv1) GetIspDataGetRequest ¶

func (c *Cdnv1) GetIspDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetIspDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetIspDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetIspDataGet for more information on using the GetIspDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetIspDataGetRequest method.
req, resp := client.GetIspDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetIspDataGetWithContext ¶

func (c *Cdnv1) GetIspDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetIspDataGetWithContext is the same as GetIspDataGet with the addition of the ability to pass a context and additional request options.

See GetIspDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetIspDataPost ¶

func (c *Cdnv1) GetIspDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetIspDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetIspDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetIspDataPost

func (*Cdnv1) GetIspDataPostRequest ¶

func (c *Cdnv1) GetIspDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetIspDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetIspDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetIspDataPost for more information on using the GetIspDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetIspDataPostRequest method.
req, resp := client.GetIspDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetIspDataPostWithContext ¶

func (c *Cdnv1) GetIspDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetIspDataPostWithContext is the same as GetIspDataPost with the addition of the ability to pass a context and additional request options.

See GetIspDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveBandwidthDataByStreamGet ¶

func (c *Cdnv1) GetLiveBandwidthDataByStreamGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveBandwidthDataByStreamGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveBandwidthDataByStreamGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveBandwidthDataByStreamGet

func (*Cdnv1) GetLiveBandwidthDataByStreamGetRequest ¶

func (c *Cdnv1) GetLiveBandwidthDataByStreamGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveBandwidthDataByStreamGetRequest generates a "ksc/request.Request" representing the client's request for the GetLiveBandwidthDataByStreamGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveBandwidthDataByStreamGet for more information on using the GetLiveBandwidthDataByStreamGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveBandwidthDataByStreamGetRequest method.
req, resp := client.GetLiveBandwidthDataByStreamGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveBandwidthDataByStreamGetWithContext ¶

func (c *Cdnv1) GetLiveBandwidthDataByStreamGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveBandwidthDataByStreamGetWithContext is the same as GetLiveBandwidthDataByStreamGet with the addition of the ability to pass a context and additional request options.

See GetLiveBandwidthDataByStreamGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveBandwidthDataByStreamPost ¶

func (c *Cdnv1) GetLiveBandwidthDataByStreamPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveBandwidthDataByStreamPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveBandwidthDataByStreamPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveBandwidthDataByStreamPost

func (*Cdnv1) GetLiveBandwidthDataByStreamPostRequest ¶

func (c *Cdnv1) GetLiveBandwidthDataByStreamPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveBandwidthDataByStreamPostRequest generates a "ksc/request.Request" representing the client's request for the GetLiveBandwidthDataByStreamPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveBandwidthDataByStreamPost for more information on using the GetLiveBandwidthDataByStreamPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveBandwidthDataByStreamPostRequest method.
req, resp := client.GetLiveBandwidthDataByStreamPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveBandwidthDataByStreamPostWithContext ¶

func (c *Cdnv1) GetLiveBandwidthDataByStreamPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveBandwidthDataByStreamPostWithContext is the same as GetLiveBandwidthDataByStreamPost with the addition of the ability to pass a context and additional request options.

See GetLiveBandwidthDataByStreamPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveFlowDataByStreamGet ¶

func (c *Cdnv1) GetLiveFlowDataByStreamGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveFlowDataByStreamGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveFlowDataByStreamGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveFlowDataByStreamGet

func (*Cdnv1) GetLiveFlowDataByStreamGetRequest ¶

func (c *Cdnv1) GetLiveFlowDataByStreamGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveFlowDataByStreamGetRequest generates a "ksc/request.Request" representing the client's request for the GetLiveFlowDataByStreamGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveFlowDataByStreamGet for more information on using the GetLiveFlowDataByStreamGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveFlowDataByStreamGetRequest method.
req, resp := client.GetLiveFlowDataByStreamGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveFlowDataByStreamGetWithContext ¶

func (c *Cdnv1) GetLiveFlowDataByStreamGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveFlowDataByStreamGetWithContext is the same as GetLiveFlowDataByStreamGet with the addition of the ability to pass a context and additional request options.

See GetLiveFlowDataByStreamGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveFlowDataByStreamPost ¶

func (c *Cdnv1) GetLiveFlowDataByStreamPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveFlowDataByStreamPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveFlowDataByStreamPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveFlowDataByStreamPost

func (*Cdnv1) GetLiveFlowDataByStreamPostRequest ¶

func (c *Cdnv1) GetLiveFlowDataByStreamPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveFlowDataByStreamPostRequest generates a "ksc/request.Request" representing the client's request for the GetLiveFlowDataByStreamPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveFlowDataByStreamPost for more information on using the GetLiveFlowDataByStreamPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveFlowDataByStreamPostRequest method.
req, resp := client.GetLiveFlowDataByStreamPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveFlowDataByStreamPostWithContext ¶

func (c *Cdnv1) GetLiveFlowDataByStreamPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveFlowDataByStreamPostWithContext is the same as GetLiveFlowDataByStreamPost with the addition of the ability to pass a context and additional request options.

See GetLiveFlowDataByStreamPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveOnlineUserDataByDomainGet ¶

func (c *Cdnv1) GetLiveOnlineUserDataByDomainGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveOnlineUserDataByDomainGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveOnlineUserDataByDomainGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveOnlineUserDataByDomainGet

func (*Cdnv1) GetLiveOnlineUserDataByDomainGetRequest ¶

func (c *Cdnv1) GetLiveOnlineUserDataByDomainGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveOnlineUserDataByDomainGetRequest generates a "ksc/request.Request" representing the client's request for the GetLiveOnlineUserDataByDomainGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveOnlineUserDataByDomainGet for more information on using the GetLiveOnlineUserDataByDomainGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveOnlineUserDataByDomainGetRequest method.
req, resp := client.GetLiveOnlineUserDataByDomainGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveOnlineUserDataByDomainGetWithContext ¶

func (c *Cdnv1) GetLiveOnlineUserDataByDomainGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveOnlineUserDataByDomainGetWithContext is the same as GetLiveOnlineUserDataByDomainGet with the addition of the ability to pass a context and additional request options.

See GetLiveOnlineUserDataByDomainGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveOnlineUserDataByDomainPost ¶

func (c *Cdnv1) GetLiveOnlineUserDataByDomainPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveOnlineUserDataByDomainPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveOnlineUserDataByDomainPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveOnlineUserDataByDomainPost

func (*Cdnv1) GetLiveOnlineUserDataByDomainPostRequest ¶

func (c *Cdnv1) GetLiveOnlineUserDataByDomainPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveOnlineUserDataByDomainPostRequest generates a "ksc/request.Request" representing the client's request for the GetLiveOnlineUserDataByDomainPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveOnlineUserDataByDomainPost for more information on using the GetLiveOnlineUserDataByDomainPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveOnlineUserDataByDomainPostRequest method.
req, resp := client.GetLiveOnlineUserDataByDomainPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveOnlineUserDataByDomainPostWithContext ¶

func (c *Cdnv1) GetLiveOnlineUserDataByDomainPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveOnlineUserDataByDomainPostWithContext is the same as GetLiveOnlineUserDataByDomainPost with the addition of the ability to pass a context and additional request options.

See GetLiveOnlineUserDataByDomainPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveOnlineUserDataByStreamGet ¶

func (c *Cdnv1) GetLiveOnlineUserDataByStreamGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveOnlineUserDataByStreamGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveOnlineUserDataByStreamGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveOnlineUserDataByStreamGet

func (*Cdnv1) GetLiveOnlineUserDataByStreamGetRequest ¶

func (c *Cdnv1) GetLiveOnlineUserDataByStreamGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveOnlineUserDataByStreamGetRequest generates a "ksc/request.Request" representing the client's request for the GetLiveOnlineUserDataByStreamGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveOnlineUserDataByStreamGet for more information on using the GetLiveOnlineUserDataByStreamGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveOnlineUserDataByStreamGetRequest method.
req, resp := client.GetLiveOnlineUserDataByStreamGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveOnlineUserDataByStreamGetWithContext ¶

func (c *Cdnv1) GetLiveOnlineUserDataByStreamGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveOnlineUserDataByStreamGetWithContext is the same as GetLiveOnlineUserDataByStreamGet with the addition of the ability to pass a context and additional request options.

See GetLiveOnlineUserDataByStreamGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveOnlineUserDataByStreamPost ¶

func (c *Cdnv1) GetLiveOnlineUserDataByStreamPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveOnlineUserDataByStreamPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveOnlineUserDataByStreamPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveOnlineUserDataByStreamPost

func (*Cdnv1) GetLiveOnlineUserDataByStreamPostRequest ¶

func (c *Cdnv1) GetLiveOnlineUserDataByStreamPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveOnlineUserDataByStreamPostRequest generates a "ksc/request.Request" representing the client's request for the GetLiveOnlineUserDataByStreamPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveOnlineUserDataByStreamPost for more information on using the GetLiveOnlineUserDataByStreamPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveOnlineUserDataByStreamPostRequest method.
req, resp := client.GetLiveOnlineUserDataByStreamPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveOnlineUserDataByStreamPostWithContext ¶

func (c *Cdnv1) GetLiveOnlineUserDataByStreamPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveOnlineUserDataByStreamPostWithContext is the same as GetLiveOnlineUserDataByStreamPost with the addition of the ability to pass a context and additional request options.

See GetLiveOnlineUserDataByStreamPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLivePlayStatDataGet ¶

func (c *Cdnv1) GetLivePlayStatDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetLivePlayStatDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLivePlayStatDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLivePlayStatDataGet

func (*Cdnv1) GetLivePlayStatDataGetRequest ¶

func (c *Cdnv1) GetLivePlayStatDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLivePlayStatDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetLivePlayStatDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLivePlayStatDataGet for more information on using the GetLivePlayStatDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLivePlayStatDataGetRequest method.
req, resp := client.GetLivePlayStatDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLivePlayStatDataGetWithContext ¶

func (c *Cdnv1) GetLivePlayStatDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLivePlayStatDataGetWithContext is the same as GetLivePlayStatDataGet with the addition of the ability to pass a context and additional request options.

See GetLivePlayStatDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLivePlayStatDataPost ¶

func (c *Cdnv1) GetLivePlayStatDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetLivePlayStatDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLivePlayStatDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLivePlayStatDataPost

func (*Cdnv1) GetLivePlayStatDataPostRequest ¶

func (c *Cdnv1) GetLivePlayStatDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLivePlayStatDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetLivePlayStatDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLivePlayStatDataPost for more information on using the GetLivePlayStatDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLivePlayStatDataPostRequest method.
req, resp := client.GetLivePlayStatDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLivePlayStatDataPostWithContext ¶

func (c *Cdnv1) GetLivePlayStatDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLivePlayStatDataPostWithContext is the same as GetLivePlayStatDataPost with the addition of the ability to pass a context and additional request options.

See GetLivePlayStatDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveTopOnlineUserDataGet ¶

func (c *Cdnv1) GetLiveTopOnlineUserDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveTopOnlineUserDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveTopOnlineUserDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveTopOnlineUserDataGet

func (*Cdnv1) GetLiveTopOnlineUserDataGetRequest ¶

func (c *Cdnv1) GetLiveTopOnlineUserDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveTopOnlineUserDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetLiveTopOnlineUserDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveTopOnlineUserDataGet for more information on using the GetLiveTopOnlineUserDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveTopOnlineUserDataGetRequest method.
req, resp := client.GetLiveTopOnlineUserDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveTopOnlineUserDataGetWithContext ¶

func (c *Cdnv1) GetLiveTopOnlineUserDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveTopOnlineUserDataGetWithContext is the same as GetLiveTopOnlineUserDataGet with the addition of the ability to pass a context and additional request options.

See GetLiveTopOnlineUserDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetLiveTopOnlineUserDataPost ¶

func (c *Cdnv1) GetLiveTopOnlineUserDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetLiveTopOnlineUserDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetLiveTopOnlineUserDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetLiveTopOnlineUserDataPost

func (*Cdnv1) GetLiveTopOnlineUserDataPostRequest ¶

func (c *Cdnv1) GetLiveTopOnlineUserDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLiveTopOnlineUserDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetLiveTopOnlineUserDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLiveTopOnlineUserDataPost for more information on using the GetLiveTopOnlineUserDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLiveTopOnlineUserDataPostRequest method.
req, resp := client.GetLiveTopOnlineUserDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetLiveTopOnlineUserDataPostWithContext ¶

func (c *Cdnv1) GetLiveTopOnlineUserDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLiveTopOnlineUserDataPostWithContext is the same as GetLiveTopOnlineUserDataPost with the addition of the ability to pass a context and additional request options.

See GetLiveTopOnlineUserDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetPeakBandwidthDataGet ¶

func (c *Cdnv1) GetPeakBandwidthDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetPeakBandwidthDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetPeakBandwidthDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetPeakBandwidthDataGet

func (*Cdnv1) GetPeakBandwidthDataGetRequest ¶

func (c *Cdnv1) GetPeakBandwidthDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPeakBandwidthDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetPeakBandwidthDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPeakBandwidthDataGet for more information on using the GetPeakBandwidthDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPeakBandwidthDataGetRequest method.
req, resp := client.GetPeakBandwidthDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetPeakBandwidthDataGetWithContext ¶

func (c *Cdnv1) GetPeakBandwidthDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPeakBandwidthDataGetWithContext is the same as GetPeakBandwidthDataGet with the addition of the ability to pass a context and additional request options.

See GetPeakBandwidthDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetPeakBandwidthDataPost ¶

func (c *Cdnv1) GetPeakBandwidthDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetPeakBandwidthDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetPeakBandwidthDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetPeakBandwidthDataPost

func (*Cdnv1) GetPeakBandwidthDataPostRequest ¶

func (c *Cdnv1) GetPeakBandwidthDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPeakBandwidthDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetPeakBandwidthDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPeakBandwidthDataPost for more information on using the GetPeakBandwidthDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPeakBandwidthDataPostRequest method.
req, resp := client.GetPeakBandwidthDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetPeakBandwidthDataPostWithContext ¶

func (c *Cdnv1) GetPeakBandwidthDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPeakBandwidthDataPostWithContext is the same as GetPeakBandwidthDataPost with the addition of the ability to pass a context and additional request options.

See GetPeakBandwidthDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetPlayTimeDataByDomainGet ¶

func (c *Cdnv1) GetPlayTimeDataByDomainGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetPlayTimeDataByDomainGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetPlayTimeDataByDomainGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetPlayTimeDataByDomainGet

func (*Cdnv1) GetPlayTimeDataByDomainGetRequest ¶

func (c *Cdnv1) GetPlayTimeDataByDomainGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPlayTimeDataByDomainGetRequest generates a "ksc/request.Request" representing the client's request for the GetPlayTimeDataByDomainGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPlayTimeDataByDomainGet for more information on using the GetPlayTimeDataByDomainGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPlayTimeDataByDomainGetRequest method.
req, resp := client.GetPlayTimeDataByDomainGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetPlayTimeDataByDomainGetWithContext ¶

func (c *Cdnv1) GetPlayTimeDataByDomainGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPlayTimeDataByDomainGetWithContext is the same as GetPlayTimeDataByDomainGet with the addition of the ability to pass a context and additional request options.

See GetPlayTimeDataByDomainGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetPlayTimeDataByDomainPost ¶

func (c *Cdnv1) GetPlayTimeDataByDomainPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetPlayTimeDataByDomainPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetPlayTimeDataByDomainPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetPlayTimeDataByDomainPost

func (*Cdnv1) GetPlayTimeDataByDomainPostRequest ¶

func (c *Cdnv1) GetPlayTimeDataByDomainPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPlayTimeDataByDomainPostRequest generates a "ksc/request.Request" representing the client's request for the GetPlayTimeDataByDomainPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPlayTimeDataByDomainPost for more information on using the GetPlayTimeDataByDomainPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPlayTimeDataByDomainPostRequest method.
req, resp := client.GetPlayTimeDataByDomainPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetPlayTimeDataByDomainPostWithContext ¶

func (c *Cdnv1) GetPlayTimeDataByDomainPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPlayTimeDataByDomainPostWithContext is the same as GetPlayTimeDataByDomainPost with the addition of the ability to pass a context and additional request options.

See GetPlayTimeDataByDomainPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetPlayTimeDataByStreamGet ¶

func (c *Cdnv1) GetPlayTimeDataByStreamGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetPlayTimeDataByStreamGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetPlayTimeDataByStreamGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetPlayTimeDataByStreamGet

func (*Cdnv1) GetPlayTimeDataByStreamGetRequest ¶

func (c *Cdnv1) GetPlayTimeDataByStreamGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPlayTimeDataByStreamGetRequest generates a "ksc/request.Request" representing the client's request for the GetPlayTimeDataByStreamGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPlayTimeDataByStreamGet for more information on using the GetPlayTimeDataByStreamGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPlayTimeDataByStreamGetRequest method.
req, resp := client.GetPlayTimeDataByStreamGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetPlayTimeDataByStreamGetWithContext ¶

func (c *Cdnv1) GetPlayTimeDataByStreamGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPlayTimeDataByStreamGetWithContext is the same as GetPlayTimeDataByStreamGet with the addition of the ability to pass a context and additional request options.

See GetPlayTimeDataByStreamGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetPlayTimeDataByStreamPost ¶

func (c *Cdnv1) GetPlayTimeDataByStreamPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetPlayTimeDataByStreamPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetPlayTimeDataByStreamPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetPlayTimeDataByStreamPost

func (*Cdnv1) GetPlayTimeDataByStreamPostRequest ¶

func (c *Cdnv1) GetPlayTimeDataByStreamPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPlayTimeDataByStreamPostRequest generates a "ksc/request.Request" representing the client's request for the GetPlayTimeDataByStreamPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPlayTimeDataByStreamPost for more information on using the GetPlayTimeDataByStreamPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPlayTimeDataByStreamPostRequest method.
req, resp := client.GetPlayTimeDataByStreamPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetPlayTimeDataByStreamPostWithContext ¶

func (c *Cdnv1) GetPlayTimeDataByStreamPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPlayTimeDataByStreamPostWithContext is the same as GetPlayTimeDataByStreamPost with the addition of the ability to pass a context and additional request options.

See GetPlayTimeDataByStreamPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspBandwidthDataGet ¶

func (c *Cdnv1) GetProvinceAndIspBandwidthDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspBandwidthDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspBandwidthDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspBandwidthDataGet

func (*Cdnv1) GetProvinceAndIspBandwidthDataGetRequest ¶

func (c *Cdnv1) GetProvinceAndIspBandwidthDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspBandwidthDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspBandwidthDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspBandwidthDataGet for more information on using the GetProvinceAndIspBandwidthDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspBandwidthDataGetRequest method.
req, resp := client.GetProvinceAndIspBandwidthDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspBandwidthDataGetWithContext ¶

func (c *Cdnv1) GetProvinceAndIspBandwidthDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspBandwidthDataGetWithContext is the same as GetProvinceAndIspBandwidthDataGet with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspBandwidthDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspBandwidthDataPost ¶

func (c *Cdnv1) GetProvinceAndIspBandwidthDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspBandwidthDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspBandwidthDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspBandwidthDataPost

func (*Cdnv1) GetProvinceAndIspBandwidthDataPostRequest ¶

func (c *Cdnv1) GetProvinceAndIspBandwidthDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspBandwidthDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspBandwidthDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspBandwidthDataPost for more information on using the GetProvinceAndIspBandwidthDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspBandwidthDataPostRequest method.
req, resp := client.GetProvinceAndIspBandwidthDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspBandwidthDataPostWithContext ¶

func (c *Cdnv1) GetProvinceAndIspBandwidthDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspBandwidthDataPostWithContext is the same as GetProvinceAndIspBandwidthDataPost with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspBandwidthDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspFlowDataGet ¶

func (c *Cdnv1) GetProvinceAndIspFlowDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspFlowDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspFlowDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspFlowDataGet

func (*Cdnv1) GetProvinceAndIspFlowDataGetRequest ¶

func (c *Cdnv1) GetProvinceAndIspFlowDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspFlowDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspFlowDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspFlowDataGet for more information on using the GetProvinceAndIspFlowDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspFlowDataGetRequest method.
req, resp := client.GetProvinceAndIspFlowDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspFlowDataGetWithContext ¶

func (c *Cdnv1) GetProvinceAndIspFlowDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspFlowDataGetWithContext is the same as GetProvinceAndIspFlowDataGet with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspFlowDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspFlowDataPost ¶

func (c *Cdnv1) GetProvinceAndIspFlowDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspFlowDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspFlowDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspFlowDataPost

func (*Cdnv1) GetProvinceAndIspFlowDataPostRequest ¶

func (c *Cdnv1) GetProvinceAndIspFlowDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspFlowDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspFlowDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspFlowDataPost for more information on using the GetProvinceAndIspFlowDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspFlowDataPostRequest method.
req, resp := client.GetProvinceAndIspFlowDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspFlowDataPostWithContext ¶

func (c *Cdnv1) GetProvinceAndIspFlowDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspFlowDataPostWithContext is the same as GetProvinceAndIspFlowDataPost with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspFlowDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspHitRateDetailedDataGet ¶

func (c *Cdnv1) GetProvinceAndIspHitRateDetailedDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspHitRateDetailedDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspHitRateDetailedDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspHitRateDetailedDataGet

func (*Cdnv1) GetProvinceAndIspHitRateDetailedDataGetRequest ¶

func (c *Cdnv1) GetProvinceAndIspHitRateDetailedDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspHitRateDetailedDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspHitRateDetailedDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspHitRateDetailedDataGet for more information on using the GetProvinceAndIspHitRateDetailedDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspHitRateDetailedDataGetRequest method.
req, resp := client.GetProvinceAndIspHitRateDetailedDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspHitRateDetailedDataGetWithContext ¶

func (c *Cdnv1) GetProvinceAndIspHitRateDetailedDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspHitRateDetailedDataGetWithContext is the same as GetProvinceAndIspHitRateDetailedDataGet with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspHitRateDetailedDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspHitRateDetailedDataPost ¶

func (c *Cdnv1) GetProvinceAndIspHitRateDetailedDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspHitRateDetailedDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspHitRateDetailedDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspHitRateDetailedDataPost

func (*Cdnv1) GetProvinceAndIspHitRateDetailedDataPostRequest ¶

func (c *Cdnv1) GetProvinceAndIspHitRateDetailedDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspHitRateDetailedDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspHitRateDetailedDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspHitRateDetailedDataPost for more information on using the GetProvinceAndIspHitRateDetailedDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspHitRateDetailedDataPostRequest method.
req, resp := client.GetProvinceAndIspHitRateDetailedDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspHitRateDetailedDataPostWithContext ¶

func (c *Cdnv1) GetProvinceAndIspHitRateDetailedDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspHitRateDetailedDataPostWithContext is the same as GetProvinceAndIspHitRateDetailedDataPost with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspHitRateDetailedDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspHttpCodeDataGet ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspHttpCodeDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspHttpCodeDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspHttpCodeDataGet

func (*Cdnv1) GetProvinceAndIspHttpCodeDataGetRequest ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspHttpCodeDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspHttpCodeDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspHttpCodeDataGet for more information on using the GetProvinceAndIspHttpCodeDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspHttpCodeDataGetRequest method.
req, resp := client.GetProvinceAndIspHttpCodeDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspHttpCodeDataGetWithContext ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspHttpCodeDataGetWithContext is the same as GetProvinceAndIspHttpCodeDataGet with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspHttpCodeDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspHttpCodeDataPost ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspHttpCodeDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspHttpCodeDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspHttpCodeDataPost

func (*Cdnv1) GetProvinceAndIspHttpCodeDataPostRequest ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspHttpCodeDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspHttpCodeDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspHttpCodeDataPost for more information on using the GetProvinceAndIspHttpCodeDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspHttpCodeDataPostRequest method.
req, resp := client.GetProvinceAndIspHttpCodeDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspHttpCodeDataPostWithContext ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspHttpCodeDataPostWithContext is the same as GetProvinceAndIspHttpCodeDataPost with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspHttpCodeDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspHttpCodeDetailedDataGet ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDetailedDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspHttpCodeDetailedDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspHttpCodeDetailedDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspHttpCodeDetailedDataGet

func (*Cdnv1) GetProvinceAndIspHttpCodeDetailedDataGetRequest ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDetailedDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspHttpCodeDetailedDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspHttpCodeDetailedDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspHttpCodeDetailedDataGet for more information on using the GetProvinceAndIspHttpCodeDetailedDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspHttpCodeDetailedDataGetRequest method.
req, resp := client.GetProvinceAndIspHttpCodeDetailedDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspHttpCodeDetailedDataGetWithContext ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDetailedDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspHttpCodeDetailedDataGetWithContext is the same as GetProvinceAndIspHttpCodeDetailedDataGet with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspHttpCodeDetailedDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspHttpCodeDetailedDataPost ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDetailedDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspHttpCodeDetailedDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspHttpCodeDetailedDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspHttpCodeDetailedDataPost

func (*Cdnv1) GetProvinceAndIspHttpCodeDetailedDataPostRequest ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDetailedDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspHttpCodeDetailedDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspHttpCodeDetailedDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspHttpCodeDetailedDataPost for more information on using the GetProvinceAndIspHttpCodeDetailedDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspHttpCodeDetailedDataPostRequest method.
req, resp := client.GetProvinceAndIspHttpCodeDetailedDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspHttpCodeDetailedDataPostWithContext ¶

func (c *Cdnv1) GetProvinceAndIspHttpCodeDetailedDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspHttpCodeDetailedDataPostWithContext is the same as GetProvinceAndIspHttpCodeDetailedDataPost with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspHttpCodeDetailedDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspPvDataGet ¶

func (c *Cdnv1) GetProvinceAndIspPvDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspPvDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspPvDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspPvDataGet

func (*Cdnv1) GetProvinceAndIspPvDataGetRequest ¶

func (c *Cdnv1) GetProvinceAndIspPvDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspPvDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspPvDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspPvDataGet for more information on using the GetProvinceAndIspPvDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspPvDataGetRequest method.
req, resp := client.GetProvinceAndIspPvDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspPvDataGetWithContext ¶

func (c *Cdnv1) GetProvinceAndIspPvDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspPvDataGetWithContext is the same as GetProvinceAndIspPvDataGet with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspPvDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetProvinceAndIspPvDataPost ¶

func (c *Cdnv1) GetProvinceAndIspPvDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetProvinceAndIspPvDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetProvinceAndIspPvDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetProvinceAndIspPvDataPost

func (*Cdnv1) GetProvinceAndIspPvDataPostRequest ¶

func (c *Cdnv1) GetProvinceAndIspPvDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProvinceAndIspPvDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetProvinceAndIspPvDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProvinceAndIspPvDataPost for more information on using the GetProvinceAndIspPvDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProvinceAndIspPvDataPostRequest method.
req, resp := client.GetProvinceAndIspPvDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetProvinceAndIspPvDataPostWithContext ¶

func (c *Cdnv1) GetProvinceAndIspPvDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProvinceAndIspPvDataPostWithContext is the same as GetProvinceAndIspPvDataPost with the addition of the ability to pass a context and additional request options.

See GetProvinceAndIspPvDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetPvDataGet ¶

func (c *Cdnv1) GetPvDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetPvDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetPvDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetPvDataGet

func (*Cdnv1) GetPvDataGetRequest ¶

func (c *Cdnv1) GetPvDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPvDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetPvDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPvDataGet for more information on using the GetPvDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPvDataGetRequest method.
req, resp := client.GetPvDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetPvDataGetWithContext ¶

func (c *Cdnv1) GetPvDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPvDataGetWithContext is the same as GetPvDataGet with the addition of the ability to pass a context and additional request options.

See GetPvDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetPvDataPost ¶

func (c *Cdnv1) GetPvDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetPvDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetPvDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetPvDataPost

func (*Cdnv1) GetPvDataPostRequest ¶

func (c *Cdnv1) GetPvDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPvDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetPvDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPvDataPost for more information on using the GetPvDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPvDataPostRequest method.
req, resp := client.GetPvDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetPvDataPostWithContext ¶

func (c *Cdnv1) GetPvDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPvDataPostWithContext is the same as GetPvDataPost with the addition of the ability to pass a context and additional request options.

See GetPvDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetRefreshOrPreloadQuotaGet ¶

func (c *Cdnv1) GetRefreshOrPreloadQuotaGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetRefreshOrPreloadQuotaGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetRefreshOrPreloadQuotaGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetRefreshOrPreloadQuotaGet

func (*Cdnv1) GetRefreshOrPreloadQuotaGetRequest ¶

func (c *Cdnv1) GetRefreshOrPreloadQuotaGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetRefreshOrPreloadQuotaGetRequest generates a "ksc/request.Request" representing the client's request for the GetRefreshOrPreloadQuotaGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetRefreshOrPreloadQuotaGet for more information on using the GetRefreshOrPreloadQuotaGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetRefreshOrPreloadQuotaGetRequest method.
req, resp := client.GetRefreshOrPreloadQuotaGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetRefreshOrPreloadQuotaGetWithContext ¶

func (c *Cdnv1) GetRefreshOrPreloadQuotaGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetRefreshOrPreloadQuotaGetWithContext is the same as GetRefreshOrPreloadQuotaGet with the addition of the ability to pass a context and additional request options.

See GetRefreshOrPreloadQuotaGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetRefreshOrPreloadQuotaPost ¶

func (c *Cdnv1) GetRefreshOrPreloadQuotaPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetRefreshOrPreloadQuotaPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetRefreshOrPreloadQuotaPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetRefreshOrPreloadQuotaPost

func (*Cdnv1) GetRefreshOrPreloadQuotaPostRequest ¶

func (c *Cdnv1) GetRefreshOrPreloadQuotaPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetRefreshOrPreloadQuotaPostRequest generates a "ksc/request.Request" representing the client's request for the GetRefreshOrPreloadQuotaPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetRefreshOrPreloadQuotaPost for more information on using the GetRefreshOrPreloadQuotaPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetRefreshOrPreloadQuotaPostRequest method.
req, resp := client.GetRefreshOrPreloadQuotaPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetRefreshOrPreloadQuotaPostWithContext ¶

func (c *Cdnv1) GetRefreshOrPreloadQuotaPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetRefreshOrPreloadQuotaPostWithContext is the same as GetRefreshOrPreloadQuotaPost with the addition of the ability to pass a context and additional request options.

See GetRefreshOrPreloadQuotaPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetRefreshOrPreloadTaskPost ¶

func (c *Cdnv1) GetRefreshOrPreloadTaskPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetRefreshOrPreloadTaskPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetRefreshOrPreloadTaskPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetRefreshOrPreloadTaskPost

func (*Cdnv1) GetRefreshOrPreloadTaskPostRequest ¶

func (c *Cdnv1) GetRefreshOrPreloadTaskPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetRefreshOrPreloadTaskPostRequest generates a "ksc/request.Request" representing the client's request for the GetRefreshOrPreloadTaskPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetRefreshOrPreloadTaskPost for more information on using the GetRefreshOrPreloadTaskPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetRefreshOrPreloadTaskPostRequest method.
req, resp := client.GetRefreshOrPreloadTaskPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetRefreshOrPreloadTaskPostWithContext ¶

func (c *Cdnv1) GetRefreshOrPreloadTaskPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetRefreshOrPreloadTaskPostWithContext is the same as GetRefreshOrPreloadTaskPost with the addition of the ability to pass a context and additional request options.

See GetRefreshOrPreloadTaskPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetServiceIpDataGet ¶

func (c *Cdnv1) GetServiceIpDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetServiceIpDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetServiceIpDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetServiceIpDataGet

func (*Cdnv1) GetServiceIpDataGetRequest ¶

func (c *Cdnv1) GetServiceIpDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetServiceIpDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetServiceIpDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetServiceIpDataGet for more information on using the GetServiceIpDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetServiceIpDataGetRequest method.
req, resp := client.GetServiceIpDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetServiceIpDataGetWithContext ¶

func (c *Cdnv1) GetServiceIpDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetServiceIpDataGetWithContext is the same as GetServiceIpDataGet with the addition of the ability to pass a context and additional request options.

See GetServiceIpDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetServiceIpDataPost ¶

func (c *Cdnv1) GetServiceIpDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetServiceIpDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetServiceIpDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetServiceIpDataPost

func (*Cdnv1) GetServiceIpDataPostRequest ¶

func (c *Cdnv1) GetServiceIpDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetServiceIpDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetServiceIpDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetServiceIpDataPost for more information on using the GetServiceIpDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetServiceIpDataPostRequest method.
req, resp := client.GetServiceIpDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetServiceIpDataPostWithContext ¶

func (c *Cdnv1) GetServiceIpDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetServiceIpDataPostWithContext is the same as GetServiceIpDataPost with the addition of the ability to pass a context and additional request options.

See GetServiceIpDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSrcHttpCodeDataGet ¶

func (c *Cdnv1) GetSrcHttpCodeDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetSrcHttpCodeDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSrcHttpCodeDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSrcHttpCodeDataGet

func (*Cdnv1) GetSrcHttpCodeDataGetRequest ¶

func (c *Cdnv1) GetSrcHttpCodeDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSrcHttpCodeDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetSrcHttpCodeDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSrcHttpCodeDataGet for more information on using the GetSrcHttpCodeDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSrcHttpCodeDataGetRequest method.
req, resp := client.GetSrcHttpCodeDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSrcHttpCodeDataGetWithContext ¶

func (c *Cdnv1) GetSrcHttpCodeDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSrcHttpCodeDataGetWithContext is the same as GetSrcHttpCodeDataGet with the addition of the ability to pass a context and additional request options.

See GetSrcHttpCodeDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSrcHttpCodeDataPost ¶

func (c *Cdnv1) GetSrcHttpCodeDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetSrcHttpCodeDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSrcHttpCodeDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSrcHttpCodeDataPost

func (*Cdnv1) GetSrcHttpCodeDataPostRequest ¶

func (c *Cdnv1) GetSrcHttpCodeDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSrcHttpCodeDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetSrcHttpCodeDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSrcHttpCodeDataPost for more information on using the GetSrcHttpCodeDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSrcHttpCodeDataPostRequest method.
req, resp := client.GetSrcHttpCodeDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSrcHttpCodeDataPostWithContext ¶

func (c *Cdnv1) GetSrcHttpCodeDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSrcHttpCodeDataPostWithContext is the same as GetSrcHttpCodeDataPost with the addition of the ability to pass a context and additional request options.

See GetSrcHttpCodeDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSrcHttpCodeDetailedDataGet ¶

func (c *Cdnv1) GetSrcHttpCodeDetailedDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetSrcHttpCodeDetailedDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSrcHttpCodeDetailedDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSrcHttpCodeDetailedDataGet

func (*Cdnv1) GetSrcHttpCodeDetailedDataGetRequest ¶

func (c *Cdnv1) GetSrcHttpCodeDetailedDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSrcHttpCodeDetailedDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetSrcHttpCodeDetailedDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSrcHttpCodeDetailedDataGet for more information on using the GetSrcHttpCodeDetailedDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSrcHttpCodeDetailedDataGetRequest method.
req, resp := client.GetSrcHttpCodeDetailedDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSrcHttpCodeDetailedDataGetWithContext ¶

func (c *Cdnv1) GetSrcHttpCodeDetailedDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSrcHttpCodeDetailedDataGetWithContext is the same as GetSrcHttpCodeDetailedDataGet with the addition of the ability to pass a context and additional request options.

See GetSrcHttpCodeDetailedDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSrcHttpCodeDetailedDataPost ¶

func (c *Cdnv1) GetSrcHttpCodeDetailedDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetSrcHttpCodeDetailedDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSrcHttpCodeDetailedDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSrcHttpCodeDetailedDataPost

func (*Cdnv1) GetSrcHttpCodeDetailedDataPostRequest ¶

func (c *Cdnv1) GetSrcHttpCodeDetailedDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSrcHttpCodeDetailedDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetSrcHttpCodeDetailedDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSrcHttpCodeDetailedDataPost for more information on using the GetSrcHttpCodeDetailedDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSrcHttpCodeDetailedDataPostRequest method.
req, resp := client.GetSrcHttpCodeDetailedDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSrcHttpCodeDetailedDataPostWithContext ¶

func (c *Cdnv1) GetSrcHttpCodeDetailedDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSrcHttpCodeDetailedDataPostWithContext is the same as GetSrcHttpCodeDetailedDataPost with the addition of the ability to pass a context and additional request options.

See GetSrcHttpCodeDetailedDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSubDomainsBandwidthDataGet ¶

func (c *Cdnv1) GetSubDomainsBandwidthDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetSubDomainsBandwidthDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSubDomainsBandwidthDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSubDomainsBandwidthDataGet

func (*Cdnv1) GetSubDomainsBandwidthDataGetRequest ¶

func (c *Cdnv1) GetSubDomainsBandwidthDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSubDomainsBandwidthDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetSubDomainsBandwidthDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSubDomainsBandwidthDataGet for more information on using the GetSubDomainsBandwidthDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSubDomainsBandwidthDataGetRequest method.
req, resp := client.GetSubDomainsBandwidthDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSubDomainsBandwidthDataGetWithContext ¶

func (c *Cdnv1) GetSubDomainsBandwidthDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSubDomainsBandwidthDataGetWithContext is the same as GetSubDomainsBandwidthDataGet with the addition of the ability to pass a context and additional request options.

See GetSubDomainsBandwidthDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSubDomainsBandwidthDataPost ¶

func (c *Cdnv1) GetSubDomainsBandwidthDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetSubDomainsBandwidthDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSubDomainsBandwidthDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSubDomainsBandwidthDataPost

func (*Cdnv1) GetSubDomainsBandwidthDataPostRequest ¶

func (c *Cdnv1) GetSubDomainsBandwidthDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSubDomainsBandwidthDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetSubDomainsBandwidthDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSubDomainsBandwidthDataPost for more information on using the GetSubDomainsBandwidthDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSubDomainsBandwidthDataPostRequest method.
req, resp := client.GetSubDomainsBandwidthDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSubDomainsBandwidthDataPostWithContext ¶

func (c *Cdnv1) GetSubDomainsBandwidthDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSubDomainsBandwidthDataPostWithContext is the same as GetSubDomainsBandwidthDataPost with the addition of the ability to pass a context and additional request options.

See GetSubDomainsBandwidthDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSubDomainsFlowDataGet ¶

func (c *Cdnv1) GetSubDomainsFlowDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetSubDomainsFlowDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSubDomainsFlowDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSubDomainsFlowDataGet

func (*Cdnv1) GetSubDomainsFlowDataGetRequest ¶

func (c *Cdnv1) GetSubDomainsFlowDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSubDomainsFlowDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetSubDomainsFlowDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSubDomainsFlowDataGet for more information on using the GetSubDomainsFlowDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSubDomainsFlowDataGetRequest method.
req, resp := client.GetSubDomainsFlowDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSubDomainsFlowDataGetWithContext ¶

func (c *Cdnv1) GetSubDomainsFlowDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSubDomainsFlowDataGetWithContext is the same as GetSubDomainsFlowDataGet with the addition of the ability to pass a context and additional request options.

See GetSubDomainsFlowDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSubDomainsFlowDataPost ¶

func (c *Cdnv1) GetSubDomainsFlowDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetSubDomainsFlowDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSubDomainsFlowDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSubDomainsFlowDataPost

func (*Cdnv1) GetSubDomainsFlowDataPostRequest ¶

func (c *Cdnv1) GetSubDomainsFlowDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSubDomainsFlowDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetSubDomainsFlowDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSubDomainsFlowDataPost for more information on using the GetSubDomainsFlowDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSubDomainsFlowDataPostRequest method.
req, resp := client.GetSubDomainsFlowDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSubDomainsFlowDataPostWithContext ¶

func (c *Cdnv1) GetSubDomainsFlowDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSubDomainsFlowDataPostWithContext is the same as GetSubDomainsFlowDataPost with the addition of the ability to pass a context and additional request options.

See GetSubDomainsFlowDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSubDomainsPvDataGet ¶

func (c *Cdnv1) GetSubDomainsPvDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetSubDomainsPvDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSubDomainsPvDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSubDomainsPvDataGet

func (*Cdnv1) GetSubDomainsPvDataGetRequest ¶

func (c *Cdnv1) GetSubDomainsPvDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSubDomainsPvDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetSubDomainsPvDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSubDomainsPvDataGet for more information on using the GetSubDomainsPvDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSubDomainsPvDataGetRequest method.
req, resp := client.GetSubDomainsPvDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSubDomainsPvDataGetWithContext ¶

func (c *Cdnv1) GetSubDomainsPvDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSubDomainsPvDataGetWithContext is the same as GetSubDomainsPvDataGet with the addition of the ability to pass a context and additional request options.

See GetSubDomainsPvDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetSubDomainsPvDataPost ¶

func (c *Cdnv1) GetSubDomainsPvDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetSubDomainsPvDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetSubDomainsPvDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetSubDomainsPvDataPost

func (*Cdnv1) GetSubDomainsPvDataPostRequest ¶

func (c *Cdnv1) GetSubDomainsPvDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetSubDomainsPvDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetSubDomainsPvDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetSubDomainsPvDataPost for more information on using the GetSubDomainsPvDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetSubDomainsPvDataPostRequest method.
req, resp := client.GetSubDomainsPvDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetSubDomainsPvDataPostWithContext ¶

func (c *Cdnv1) GetSubDomainsPvDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetSubDomainsPvDataPostWithContext is the same as GetSubDomainsPvDataPost with the addition of the ability to pass a context and additional request options.

See GetSubDomainsPvDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetTopIpDataGet ¶

func (c *Cdnv1) GetTopIpDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetTopIpDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetTopIpDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetTopIpDataGet

func (*Cdnv1) GetTopIpDataGetRequest ¶

func (c *Cdnv1) GetTopIpDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetTopIpDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetTopIpDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetTopIpDataGet for more information on using the GetTopIpDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetTopIpDataGetRequest method.
req, resp := client.GetTopIpDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetTopIpDataGetWithContext ¶

func (c *Cdnv1) GetTopIpDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetTopIpDataGetWithContext is the same as GetTopIpDataGet with the addition of the ability to pass a context and additional request options.

See GetTopIpDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetTopIpDataPost ¶

func (c *Cdnv1) GetTopIpDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetTopIpDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetTopIpDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetTopIpDataPost

func (*Cdnv1) GetTopIpDataPostRequest ¶

func (c *Cdnv1) GetTopIpDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetTopIpDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetTopIpDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetTopIpDataPost for more information on using the GetTopIpDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetTopIpDataPostRequest method.
req, resp := client.GetTopIpDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetTopIpDataPostWithContext ¶

func (c *Cdnv1) GetTopIpDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetTopIpDataPostWithContext is the same as GetTopIpDataPost with the addition of the ability to pass a context and additional request options.

See GetTopIpDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetTopReferDataGet ¶

func (c *Cdnv1) GetTopReferDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetTopReferDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetTopReferDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetTopReferDataGet

func (*Cdnv1) GetTopReferDataGetRequest ¶

func (c *Cdnv1) GetTopReferDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetTopReferDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetTopReferDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetTopReferDataGet for more information on using the GetTopReferDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetTopReferDataGetRequest method.
req, resp := client.GetTopReferDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetTopReferDataGetWithContext ¶

func (c *Cdnv1) GetTopReferDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetTopReferDataGetWithContext is the same as GetTopReferDataGet with the addition of the ability to pass a context and additional request options.

See GetTopReferDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetTopReferDataPost ¶

func (c *Cdnv1) GetTopReferDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetTopReferDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetTopReferDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetTopReferDataPost

func (*Cdnv1) GetTopReferDataPostRequest ¶

func (c *Cdnv1) GetTopReferDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetTopReferDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetTopReferDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetTopReferDataPost for more information on using the GetTopReferDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetTopReferDataPostRequest method.
req, resp := client.GetTopReferDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetTopReferDataPostWithContext ¶

func (c *Cdnv1) GetTopReferDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetTopReferDataPostWithContext is the same as GetTopReferDataPost with the addition of the ability to pass a context and additional request options.

See GetTopReferDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetTopUrlDataGet ¶

func (c *Cdnv1) GetTopUrlDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetTopUrlDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetTopUrlDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetTopUrlDataGet

func (*Cdnv1) GetTopUrlDataGetRequest ¶

func (c *Cdnv1) GetTopUrlDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetTopUrlDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetTopUrlDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetTopUrlDataGet for more information on using the GetTopUrlDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetTopUrlDataGetRequest method.
req, resp := client.GetTopUrlDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetTopUrlDataGetWithContext ¶

func (c *Cdnv1) GetTopUrlDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetTopUrlDataGetWithContext is the same as GetTopUrlDataGet with the addition of the ability to pass a context and additional request options.

See GetTopUrlDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetTopUrlDataPost ¶

func (c *Cdnv1) GetTopUrlDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetTopUrlDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetTopUrlDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetTopUrlDataPost

func (*Cdnv1) GetTopUrlDataPostRequest ¶

func (c *Cdnv1) GetTopUrlDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetTopUrlDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetTopUrlDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetTopUrlDataPost for more information on using the GetTopUrlDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetTopUrlDataPostRequest method.
req, resp := client.GetTopUrlDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetTopUrlDataPostWithContext ¶

func (c *Cdnv1) GetTopUrlDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetTopUrlDataPostWithContext is the same as GetTopUrlDataPost with the addition of the ability to pass a context and additional request options.

See GetTopUrlDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetUvDataGet ¶

func (c *Cdnv1) GetUvDataGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetUvDataGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetUvDataGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetUvDataGet

func (*Cdnv1) GetUvDataGetRequest ¶

func (c *Cdnv1) GetUvDataGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetUvDataGetRequest generates a "ksc/request.Request" representing the client's request for the GetUvDataGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetUvDataGet for more information on using the GetUvDataGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetUvDataGetRequest method.
req, resp := client.GetUvDataGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetUvDataGetWithContext ¶

func (c *Cdnv1) GetUvDataGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetUvDataGetWithContext is the same as GetUvDataGet with the addition of the ability to pass a context and additional request options.

See GetUvDataGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetUvDataPost ¶

func (c *Cdnv1) GetUvDataPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetUvDataPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetUvDataPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetUvDataPost

func (*Cdnv1) GetUvDataPostRequest ¶

func (c *Cdnv1) GetUvDataPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetUvDataPostRequest generates a "ksc/request.Request" representing the client's request for the GetUvDataPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetUvDataPost for more information on using the GetUvDataPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetUvDataPostRequest method.
req, resp := client.GetUvDataPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetUvDataPostWithContext ¶

func (c *Cdnv1) GetUvDataPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetUvDataPostWithContext is the same as GetUvDataPost with the addition of the ability to pass a context and additional request options.

See GetUvDataPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetVideoSeekConfigGet ¶

func (c *Cdnv1) GetVideoSeekConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

GetVideoSeekConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetVideoSeekConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetVideoSeekConfigGet

func (*Cdnv1) GetVideoSeekConfigGetRequest ¶

func (c *Cdnv1) GetVideoSeekConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetVideoSeekConfigGetRequest generates a "ksc/request.Request" representing the client's request for the GetVideoSeekConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetVideoSeekConfigGet for more information on using the GetVideoSeekConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetVideoSeekConfigGetRequest method.
req, resp := client.GetVideoSeekConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetVideoSeekConfigGetWithContext ¶

func (c *Cdnv1) GetVideoSeekConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetVideoSeekConfigGetWithContext is the same as GetVideoSeekConfigGet with the addition of the ability to pass a context and additional request options.

See GetVideoSeekConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) GetVideoSeekConfigPost ¶

func (c *Cdnv1) GetVideoSeekConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

GetVideoSeekConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation GetVideoSeekConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/GetVideoSeekConfigPost

func (*Cdnv1) GetVideoSeekConfigPostRequest ¶

func (c *Cdnv1) GetVideoSeekConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetVideoSeekConfigPostRequest generates a "ksc/request.Request" representing the client's request for the GetVideoSeekConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetVideoSeekConfigPost for more information on using the GetVideoSeekConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetVideoSeekConfigPostRequest method.
req, resp := client.GetVideoSeekConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) GetVideoSeekConfigPostWithContext ¶

func (c *Cdnv1) GetVideoSeekConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetVideoSeekConfigPostWithContext is the same as GetVideoSeekConfigPost with the addition of the ability to pass a context and additional request options.

See GetVideoSeekConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) ModifyCdnDomainBasicInfoGet ¶

func (c *Cdnv1) ModifyCdnDomainBasicInfoGet(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyCdnDomainBasicInfoGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation ModifyCdnDomainBasicInfoGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/ModifyCdnDomainBasicInfoGet

func (*Cdnv1) ModifyCdnDomainBasicInfoGetRequest ¶

func (c *Cdnv1) ModifyCdnDomainBasicInfoGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyCdnDomainBasicInfoGetRequest generates a "ksc/request.Request" representing the client's request for the ModifyCdnDomainBasicInfoGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyCdnDomainBasicInfoGet for more information on using the ModifyCdnDomainBasicInfoGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyCdnDomainBasicInfoGetRequest method.
req, resp := client.ModifyCdnDomainBasicInfoGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) ModifyCdnDomainBasicInfoGetWithContext ¶

func (c *Cdnv1) ModifyCdnDomainBasicInfoGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyCdnDomainBasicInfoGetWithContext is the same as ModifyCdnDomainBasicInfoGet with the addition of the ability to pass a context and additional request options.

See ModifyCdnDomainBasicInfoGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) ModifyCdnDomainBasicInfoPost ¶

func (c *Cdnv1) ModifyCdnDomainBasicInfoPost(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyCdnDomainBasicInfoPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation ModifyCdnDomainBasicInfoPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/ModifyCdnDomainBasicInfoPost

func (*Cdnv1) ModifyCdnDomainBasicInfoPostRequest ¶

func (c *Cdnv1) ModifyCdnDomainBasicInfoPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyCdnDomainBasicInfoPostRequest generates a "ksc/request.Request" representing the client's request for the ModifyCdnDomainBasicInfoPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyCdnDomainBasicInfoPost for more information on using the ModifyCdnDomainBasicInfoPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyCdnDomainBasicInfoPostRequest method.
req, resp := client.ModifyCdnDomainBasicInfoPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) ModifyCdnDomainBasicInfoPostWithContext ¶

func (c *Cdnv1) ModifyCdnDomainBasicInfoPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyCdnDomainBasicInfoPostWithContext is the same as ModifyCdnDomainBasicInfoPost with the addition of the ability to pass a context and additional request options.

See ModifyCdnDomainBasicInfoPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) PreloadCachesPost ¶

func (c *Cdnv1) PreloadCachesPost(input *map[string]interface{}) (*map[string]interface{}, error)

PreloadCachesPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation PreloadCachesPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/PreloadCachesPost

func (*Cdnv1) PreloadCachesPostRequest ¶

func (c *Cdnv1) PreloadCachesPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

PreloadCachesPostRequest generates a "ksc/request.Request" representing the client's request for the PreloadCachesPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See PreloadCachesPost for more information on using the PreloadCachesPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the PreloadCachesPostRequest method.
req, resp := client.PreloadCachesPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) PreloadCachesPostWithContext ¶

func (c *Cdnv1) PreloadCachesPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

PreloadCachesPostWithContext is the same as PreloadCachesPost with the addition of the ability to pass a context and additional request options.

See PreloadCachesPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) RefreshCachesPost ¶

func (c *Cdnv1) RefreshCachesPost(input *map[string]interface{}) (*map[string]interface{}, error)

RefreshCachesPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation RefreshCachesPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/RefreshCachesPost

func (*Cdnv1) RefreshCachesPostRequest ¶

func (c *Cdnv1) RefreshCachesPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RefreshCachesPostRequest generates a "ksc/request.Request" representing the client's request for the RefreshCachesPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RefreshCachesPost for more information on using the RefreshCachesPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RefreshCachesPostRequest method.
req, resp := client.RefreshCachesPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) RefreshCachesPostWithContext ¶

func (c *Cdnv1) RefreshCachesPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RefreshCachesPostWithContext is the same as RefreshCachesPost with the addition of the ability to pass a context and additional request options.

See RefreshCachesPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) RemoveCertificatesGet ¶

func (c *Cdnv1) RemoveCertificatesGet(input *map[string]interface{}) (*map[string]interface{}, error)

RemoveCertificatesGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation RemoveCertificatesGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/RemoveCertificatesGet

func (*Cdnv1) RemoveCertificatesGetRequest ¶

func (c *Cdnv1) RemoveCertificatesGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RemoveCertificatesGetRequest generates a "ksc/request.Request" representing the client's request for the RemoveCertificatesGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RemoveCertificatesGet for more information on using the RemoveCertificatesGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RemoveCertificatesGetRequest method.
req, resp := client.RemoveCertificatesGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) RemoveCertificatesGetWithContext ¶

func (c *Cdnv1) RemoveCertificatesGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RemoveCertificatesGetWithContext is the same as RemoveCertificatesGet with the addition of the ability to pass a context and additional request options.

See RemoveCertificatesGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) RemoveCertificatesPost ¶

func (c *Cdnv1) RemoveCertificatesPost(input *map[string]interface{}) (*map[string]interface{}, error)

RemoveCertificatesPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation RemoveCertificatesPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/RemoveCertificatesPost

func (*Cdnv1) RemoveCertificatesPostRequest ¶

func (c *Cdnv1) RemoveCertificatesPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RemoveCertificatesPostRequest generates a "ksc/request.Request" representing the client's request for the RemoveCertificatesPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RemoveCertificatesPost for more information on using the RemoveCertificatesPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RemoveCertificatesPostRequest method.
req, resp := client.RemoveCertificatesPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) RemoveCertificatesPostWithContext ¶

func (c *Cdnv1) RemoveCertificatesPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RemoveCertificatesPostWithContext is the same as RemoveCertificatesPost with the addition of the ability to pass a context and additional request options.

See RemoveCertificatesPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetBackOriginHostConfigGet ¶

func (c *Cdnv1) SetBackOriginHostConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetBackOriginHostConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetBackOriginHostConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetBackOriginHostConfigGet

func (*Cdnv1) SetBackOriginHostConfigGetRequest ¶

func (c *Cdnv1) SetBackOriginHostConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetBackOriginHostConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetBackOriginHostConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetBackOriginHostConfigGet for more information on using the SetBackOriginHostConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetBackOriginHostConfigGetRequest method.
req, resp := client.SetBackOriginHostConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetBackOriginHostConfigGetWithContext ¶

func (c *Cdnv1) SetBackOriginHostConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetBackOriginHostConfigGetWithContext is the same as SetBackOriginHostConfigGet with the addition of the ability to pass a context and additional request options.

See SetBackOriginHostConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetBackOriginHostConfigPost ¶

func (c *Cdnv1) SetBackOriginHostConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetBackOriginHostConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetBackOriginHostConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetBackOriginHostConfigPost

func (*Cdnv1) SetBackOriginHostConfigPostRequest ¶

func (c *Cdnv1) SetBackOriginHostConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetBackOriginHostConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetBackOriginHostConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetBackOriginHostConfigPost for more information on using the SetBackOriginHostConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetBackOriginHostConfigPostRequest method.
req, resp := client.SetBackOriginHostConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetBackOriginHostConfigPostWithContext ¶

func (c *Cdnv1) SetBackOriginHostConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetBackOriginHostConfigPostWithContext is the same as SetBackOriginHostConfigPost with the addition of the ability to pass a context and additional request options.

See SetBackOriginHostConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetCacheRuleConfigPost ¶

func (c *Cdnv1) SetCacheRuleConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetCacheRuleConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetCacheRuleConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetCacheRuleConfigPost

func (*Cdnv1) SetCacheRuleConfigPostRequest ¶

func (c *Cdnv1) SetCacheRuleConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetCacheRuleConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetCacheRuleConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetCacheRuleConfigPost for more information on using the SetCacheRuleConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetCacheRuleConfigPostRequest method.
req, resp := client.SetCacheRuleConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetCacheRuleConfigPostWithContext ¶

func (c *Cdnv1) SetCacheRuleConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetCacheRuleConfigPostWithContext is the same as SetCacheRuleConfigPost with the addition of the ability to pass a context and additional request options.

See SetCacheRuleConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetCertificateGet ¶

func (c *Cdnv1) SetCertificateGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetCertificateGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetCertificateGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetCertificateGet

func (*Cdnv1) SetCertificateGetRequest ¶

func (c *Cdnv1) SetCertificateGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetCertificateGetRequest generates a "ksc/request.Request" representing the client's request for the SetCertificateGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetCertificateGet for more information on using the SetCertificateGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetCertificateGetRequest method.
req, resp := client.SetCertificateGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetCertificateGetWithContext ¶

func (c *Cdnv1) SetCertificateGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetCertificateGetWithContext is the same as SetCertificateGet with the addition of the ability to pass a context and additional request options.

See SetCertificateGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetCertificatePost ¶

func (c *Cdnv1) SetCertificatePost(input *map[string]interface{}) (*map[string]interface{}, error)

SetCertificatePost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetCertificatePost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetCertificatePost

func (*Cdnv1) SetCertificatePostRequest ¶

func (c *Cdnv1) SetCertificatePostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetCertificatePostRequest generates a "ksc/request.Request" representing the client's request for the SetCertificatePost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetCertificatePost for more information on using the SetCertificatePost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetCertificatePostRequest method.
req, resp := client.SetCertificatePostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetCertificatePostWithContext ¶

func (c *Cdnv1) SetCertificatePostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetCertificatePostWithContext is the same as SetCertificatePost with the addition of the ability to pass a context and additional request options.

See SetCertificatePost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetDomainConfigsPost ¶

func (c *Cdnv1) SetDomainConfigsPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetDomainConfigsPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetDomainConfigsPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetDomainConfigsPost

func (*Cdnv1) SetDomainConfigsPostRequest ¶

func (c *Cdnv1) SetDomainConfigsPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetDomainConfigsPostRequest generates a "ksc/request.Request" representing the client's request for the SetDomainConfigsPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetDomainConfigsPost for more information on using the SetDomainConfigsPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetDomainConfigsPostRequest method.
req, resp := client.SetDomainConfigsPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetDomainConfigsPostWithContext ¶

func (c *Cdnv1) SetDomainConfigsPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetDomainConfigsPostWithContext is the same as SetDomainConfigsPost with the addition of the ability to pass a context and additional request options.

See SetDomainConfigsPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetDomainLogServiceGet ¶

func (c *Cdnv1) SetDomainLogServiceGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetDomainLogServiceGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetDomainLogServiceGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetDomainLogServiceGet

func (*Cdnv1) SetDomainLogServiceGetRequest ¶

func (c *Cdnv1) SetDomainLogServiceGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetDomainLogServiceGetRequest generates a "ksc/request.Request" representing the client's request for the SetDomainLogServiceGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetDomainLogServiceGet for more information on using the SetDomainLogServiceGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetDomainLogServiceGetRequest method.
req, resp := client.SetDomainLogServiceGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetDomainLogServiceGetWithContext ¶

func (c *Cdnv1) SetDomainLogServiceGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetDomainLogServiceGetWithContext is the same as SetDomainLogServiceGet with the addition of the ability to pass a context and additional request options.

See SetDomainLogServiceGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetDomainLogServicePost ¶

func (c *Cdnv1) SetDomainLogServicePost(input *map[string]interface{}) (*map[string]interface{}, error)

SetDomainLogServicePost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetDomainLogServicePost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetDomainLogServicePost

func (*Cdnv1) SetDomainLogServicePostRequest ¶

func (c *Cdnv1) SetDomainLogServicePostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetDomainLogServicePostRequest generates a "ksc/request.Request" representing the client's request for the SetDomainLogServicePost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetDomainLogServicePost for more information on using the SetDomainLogServicePost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetDomainLogServicePostRequest method.
req, resp := client.SetDomainLogServicePostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetDomainLogServicePostWithContext ¶

func (c *Cdnv1) SetDomainLogServicePostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetDomainLogServicePostWithContext is the same as SetDomainLogServicePost with the addition of the ability to pass a context and additional request options.

See SetDomainLogServicePost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetErrorPageConfigPost ¶

func (c *Cdnv1) SetErrorPageConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetErrorPageConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetErrorPageConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetErrorPageConfigPost

func (*Cdnv1) SetErrorPageConfigPostRequest ¶

func (c *Cdnv1) SetErrorPageConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetErrorPageConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetErrorPageConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetErrorPageConfigPost for more information on using the SetErrorPageConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetErrorPageConfigPostRequest method.
req, resp := client.SetErrorPageConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetErrorPageConfigPostWithContext ¶

func (c *Cdnv1) SetErrorPageConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetErrorPageConfigPostWithContext is the same as SetErrorPageConfigPost with the addition of the ability to pass a context and additional request options.

See SetErrorPageConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetForceRedirectConfigGet ¶

func (c *Cdnv1) SetForceRedirectConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetForceRedirectConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetForceRedirectConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetForceRedirectConfigGet

func (*Cdnv1) SetForceRedirectConfigGetRequest ¶

func (c *Cdnv1) SetForceRedirectConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetForceRedirectConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetForceRedirectConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetForceRedirectConfigGet for more information on using the SetForceRedirectConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetForceRedirectConfigGetRequest method.
req, resp := client.SetForceRedirectConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetForceRedirectConfigGetWithContext ¶

func (c *Cdnv1) SetForceRedirectConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetForceRedirectConfigGetWithContext is the same as SetForceRedirectConfigGet with the addition of the ability to pass a context and additional request options.

See SetForceRedirectConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetForceRedirectConfigPost ¶

func (c *Cdnv1) SetForceRedirectConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetForceRedirectConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetForceRedirectConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetForceRedirectConfigPost

func (*Cdnv1) SetForceRedirectConfigPostRequest ¶

func (c *Cdnv1) SetForceRedirectConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetForceRedirectConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetForceRedirectConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetForceRedirectConfigPost for more information on using the SetForceRedirectConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetForceRedirectConfigPostRequest method.
req, resp := client.SetForceRedirectConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetForceRedirectConfigPostWithContext ¶

func (c *Cdnv1) SetForceRedirectConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetForceRedirectConfigPostWithContext is the same as SetForceRedirectConfigPost with the addition of the ability to pass a context and additional request options.

See SetForceRedirectConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetHttp2OptionConfigGet ¶

func (c *Cdnv1) SetHttp2OptionConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetHttp2OptionConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetHttp2OptionConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetHttp2OptionConfigGet

func (*Cdnv1) SetHttp2OptionConfigGetRequest ¶

func (c *Cdnv1) SetHttp2OptionConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetHttp2OptionConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetHttp2OptionConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetHttp2OptionConfigGet for more information on using the SetHttp2OptionConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetHttp2OptionConfigGetRequest method.
req, resp := client.SetHttp2OptionConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetHttp2OptionConfigGetWithContext ¶

func (c *Cdnv1) SetHttp2OptionConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetHttp2OptionConfigGetWithContext is the same as SetHttp2OptionConfigGet with the addition of the ability to pass a context and additional request options.

See SetHttp2OptionConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetHttp2OptionConfigPost ¶

func (c *Cdnv1) SetHttp2OptionConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetHttp2OptionConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetHttp2OptionConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetHttp2OptionConfigPost

func (*Cdnv1) SetHttp2OptionConfigPostRequest ¶

func (c *Cdnv1) SetHttp2OptionConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetHttp2OptionConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetHttp2OptionConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetHttp2OptionConfigPost for more information on using the SetHttp2OptionConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetHttp2OptionConfigPostRequest method.
req, resp := client.SetHttp2OptionConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetHttp2OptionConfigPostWithContext ¶

func (c *Cdnv1) SetHttp2OptionConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetHttp2OptionConfigPostWithContext is the same as SetHttp2OptionConfigPost with the addition of the ability to pass a context and additional request options.

See SetHttp2OptionConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetHttpHeadersConfigGet ¶

func (c *Cdnv1) SetHttpHeadersConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetHttpHeadersConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetHttpHeadersConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetHttpHeadersConfigGet

func (*Cdnv1) SetHttpHeadersConfigGetRequest ¶

func (c *Cdnv1) SetHttpHeadersConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetHttpHeadersConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetHttpHeadersConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetHttpHeadersConfigGet for more information on using the SetHttpHeadersConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetHttpHeadersConfigGetRequest method.
req, resp := client.SetHttpHeadersConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetHttpHeadersConfigGetWithContext ¶

func (c *Cdnv1) SetHttpHeadersConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetHttpHeadersConfigGetWithContext is the same as SetHttpHeadersConfigGet with the addition of the ability to pass a context and additional request options.

See SetHttpHeadersConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetHttpHeadersConfigPost ¶

func (c *Cdnv1) SetHttpHeadersConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetHttpHeadersConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetHttpHeadersConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetHttpHeadersConfigPost

func (*Cdnv1) SetHttpHeadersConfigPostRequest ¶

func (c *Cdnv1) SetHttpHeadersConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetHttpHeadersConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetHttpHeadersConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetHttpHeadersConfigPost for more information on using the SetHttpHeadersConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetHttpHeadersConfigPostRequest method.
req, resp := client.SetHttpHeadersConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetHttpHeadersConfigPostWithContext ¶

func (c *Cdnv1) SetHttpHeadersConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetHttpHeadersConfigPostWithContext is the same as SetHttpHeadersConfigPost with the addition of the ability to pass a context and additional request options.

See SetHttpHeadersConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetIpProtectionConfigGet ¶

func (c *Cdnv1) SetIpProtectionConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetIpProtectionConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetIpProtectionConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetIpProtectionConfigGet

func (*Cdnv1) SetIpProtectionConfigGetRequest ¶

func (c *Cdnv1) SetIpProtectionConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetIpProtectionConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetIpProtectionConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetIpProtectionConfigGet for more information on using the SetIpProtectionConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetIpProtectionConfigGetRequest method.
req, resp := client.SetIpProtectionConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetIpProtectionConfigGetWithContext ¶

func (c *Cdnv1) SetIpProtectionConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetIpProtectionConfigGetWithContext is the same as SetIpProtectionConfigGet with the addition of the ability to pass a context and additional request options.

See SetIpProtectionConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetIpProtectionConfigPost ¶

func (c *Cdnv1) SetIpProtectionConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetIpProtectionConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetIpProtectionConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetIpProtectionConfigPost

func (*Cdnv1) SetIpProtectionConfigPostRequest ¶

func (c *Cdnv1) SetIpProtectionConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetIpProtectionConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetIpProtectionConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetIpProtectionConfigPost for more information on using the SetIpProtectionConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetIpProtectionConfigPostRequest method.
req, resp := client.SetIpProtectionConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetIpProtectionConfigPostWithContext ¶

func (c *Cdnv1) SetIpProtectionConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetIpProtectionConfigPostWithContext is the same as SetIpProtectionConfigPost with the addition of the ability to pass a context and additional request options.

See SetIpProtectionConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetOriginAdvancedConfigPost ¶

func (c *Cdnv1) SetOriginAdvancedConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetOriginAdvancedConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetOriginAdvancedConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetOriginAdvancedConfigPost

func (*Cdnv1) SetOriginAdvancedConfigPostRequest ¶

func (c *Cdnv1) SetOriginAdvancedConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetOriginAdvancedConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetOriginAdvancedConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetOriginAdvancedConfigPost for more information on using the SetOriginAdvancedConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetOriginAdvancedConfigPostRequest method.
req, resp := client.SetOriginAdvancedConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetOriginAdvancedConfigPostWithContext ¶

func (c *Cdnv1) SetOriginAdvancedConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetOriginAdvancedConfigPostWithContext is the same as SetOriginAdvancedConfigPost with the addition of the ability to pass a context and additional request options.

See SetOriginAdvancedConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetPageCompressConfigGet ¶

func (c *Cdnv1) SetPageCompressConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetPageCompressConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetPageCompressConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetPageCompressConfigGet

func (*Cdnv1) SetPageCompressConfigGetRequest ¶

func (c *Cdnv1) SetPageCompressConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetPageCompressConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetPageCompressConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetPageCompressConfigGet for more information on using the SetPageCompressConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetPageCompressConfigGetRequest method.
req, resp := client.SetPageCompressConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetPageCompressConfigGetWithContext ¶

func (c *Cdnv1) SetPageCompressConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetPageCompressConfigGetWithContext is the same as SetPageCompressConfigGet with the addition of the ability to pass a context and additional request options.

See SetPageCompressConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetPageCompressConfigPost ¶

func (c *Cdnv1) SetPageCompressConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetPageCompressConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetPageCompressConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetPageCompressConfigPost

func (*Cdnv1) SetPageCompressConfigPostRequest ¶

func (c *Cdnv1) SetPageCompressConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetPageCompressConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetPageCompressConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetPageCompressConfigPost for more information on using the SetPageCompressConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetPageCompressConfigPostRequest method.
req, resp := client.SetPageCompressConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetPageCompressConfigPostWithContext ¶

func (c *Cdnv1) SetPageCompressConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetPageCompressConfigPostWithContext is the same as SetPageCompressConfigPost with the addition of the ability to pass a context and additional request options.

See SetPageCompressConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetReferProtectionConfigGet ¶

func (c *Cdnv1) SetReferProtectionConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetReferProtectionConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetReferProtectionConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetReferProtectionConfigGet

func (*Cdnv1) SetReferProtectionConfigGetRequest ¶

func (c *Cdnv1) SetReferProtectionConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetReferProtectionConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetReferProtectionConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetReferProtectionConfigGet for more information on using the SetReferProtectionConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetReferProtectionConfigGetRequest method.
req, resp := client.SetReferProtectionConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetReferProtectionConfigGetWithContext ¶

func (c *Cdnv1) SetReferProtectionConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetReferProtectionConfigGetWithContext is the same as SetReferProtectionConfigGet with the addition of the ability to pass a context and additional request options.

See SetReferProtectionConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetReferProtectionConfigPost ¶

func (c *Cdnv1) SetReferProtectionConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetReferProtectionConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetReferProtectionConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetReferProtectionConfigPost

func (*Cdnv1) SetReferProtectionConfigPostRequest ¶

func (c *Cdnv1) SetReferProtectionConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetReferProtectionConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetReferProtectionConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetReferProtectionConfigPost for more information on using the SetReferProtectionConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetReferProtectionConfigPostRequest method.
req, resp := client.SetReferProtectionConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetReferProtectionConfigPostWithContext ¶

func (c *Cdnv1) SetReferProtectionConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetReferProtectionConfigPostWithContext is the same as SetReferProtectionConfigPost with the addition of the ability to pass a context and additional request options.

See SetReferProtectionConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetRemarkConfigGet ¶

func (c *Cdnv1) SetRemarkConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetRemarkConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetRemarkConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetRemarkConfigGet

func (*Cdnv1) SetRemarkConfigGetRequest ¶

func (c *Cdnv1) SetRemarkConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetRemarkConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetRemarkConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetRemarkConfigGet for more information on using the SetRemarkConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetRemarkConfigGetRequest method.
req, resp := client.SetRemarkConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetRemarkConfigGetWithContext ¶

func (c *Cdnv1) SetRemarkConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetRemarkConfigGetWithContext is the same as SetRemarkConfigGet with the addition of the ability to pass a context and additional request options.

See SetRemarkConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetRemarkConfigPost ¶

func (c *Cdnv1) SetRemarkConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetRemarkConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetRemarkConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetRemarkConfigPost

func (*Cdnv1) SetRemarkConfigPostRequest ¶

func (c *Cdnv1) SetRemarkConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetRemarkConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetRemarkConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetRemarkConfigPost for more information on using the SetRemarkConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetRemarkConfigPostRequest method.
req, resp := client.SetRemarkConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetRemarkConfigPostWithContext ¶

func (c *Cdnv1) SetRemarkConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetRemarkConfigPostWithContext is the same as SetRemarkConfigPost with the addition of the ability to pass a context and additional request options.

See SetRemarkConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetRequestAuthConfigGet ¶

func (c *Cdnv1) SetRequestAuthConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetRequestAuthConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetRequestAuthConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetRequestAuthConfigGet

func (*Cdnv1) SetRequestAuthConfigGetRequest ¶

func (c *Cdnv1) SetRequestAuthConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetRequestAuthConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetRequestAuthConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetRequestAuthConfigGet for more information on using the SetRequestAuthConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetRequestAuthConfigGetRequest method.
req, resp := client.SetRequestAuthConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetRequestAuthConfigGetWithContext ¶

func (c *Cdnv1) SetRequestAuthConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetRequestAuthConfigGetWithContext is the same as SetRequestAuthConfigGet with the addition of the ability to pass a context and additional request options.

See SetRequestAuthConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetRequestAuthConfigPost ¶

func (c *Cdnv1) SetRequestAuthConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetRequestAuthConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetRequestAuthConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetRequestAuthConfigPost

func (*Cdnv1) SetRequestAuthConfigPostRequest ¶

func (c *Cdnv1) SetRequestAuthConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetRequestAuthConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetRequestAuthConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetRequestAuthConfigPost for more information on using the SetRequestAuthConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetRequestAuthConfigPostRequest method.
req, resp := client.SetRequestAuthConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetRequestAuthConfigPostWithContext ¶

func (c *Cdnv1) SetRequestAuthConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetRequestAuthConfigPostWithContext is the same as SetRequestAuthConfigPost with the addition of the ability to pass a context and additional request options.

See SetRequestAuthConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetTestUrlConfigGet ¶

func (c *Cdnv1) SetTestUrlConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetTestUrlConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetTestUrlConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetTestUrlConfigGet

func (*Cdnv1) SetTestUrlConfigGetRequest ¶

func (c *Cdnv1) SetTestUrlConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetTestUrlConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetTestUrlConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetTestUrlConfigGet for more information on using the SetTestUrlConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetTestUrlConfigGetRequest method.
req, resp := client.SetTestUrlConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetTestUrlConfigGetWithContext ¶

func (c *Cdnv1) SetTestUrlConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetTestUrlConfigGetWithContext is the same as SetTestUrlConfigGet with the addition of the ability to pass a context and additional request options.

See SetTestUrlConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetTestUrlConfigPost ¶

func (c *Cdnv1) SetTestUrlConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetTestUrlConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetTestUrlConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetTestUrlConfigPost

func (*Cdnv1) SetTestUrlConfigPostRequest ¶

func (c *Cdnv1) SetTestUrlConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetTestUrlConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetTestUrlConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetTestUrlConfigPost for more information on using the SetTestUrlConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetTestUrlConfigPostRequest method.
req, resp := client.SetTestUrlConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetTestUrlConfigPostWithContext ¶

func (c *Cdnv1) SetTestUrlConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetTestUrlConfigPostWithContext is the same as SetTestUrlConfigPost with the addition of the ability to pass a context and additional request options.

See SetTestUrlConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetVideoSeekConfigGet ¶

func (c *Cdnv1) SetVideoSeekConfigGet(input *map[string]interface{}) (*map[string]interface{}, error)

SetVideoSeekConfigGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetVideoSeekConfigGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetVideoSeekConfigGet

func (*Cdnv1) SetVideoSeekConfigGetRequest ¶

func (c *Cdnv1) SetVideoSeekConfigGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetVideoSeekConfigGetRequest generates a "ksc/request.Request" representing the client's request for the SetVideoSeekConfigGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetVideoSeekConfigGet for more information on using the SetVideoSeekConfigGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetVideoSeekConfigGetRequest method.
req, resp := client.SetVideoSeekConfigGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetVideoSeekConfigGetWithContext ¶

func (c *Cdnv1) SetVideoSeekConfigGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetVideoSeekConfigGetWithContext is the same as SetVideoSeekConfigGet with the addition of the ability to pass a context and additional request options.

See SetVideoSeekConfigGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) SetVideoSeekConfigPost ¶

func (c *Cdnv1) SetVideoSeekConfigPost(input *map[string]interface{}) (*map[string]interface{}, error)

SetVideoSeekConfigPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation SetVideoSeekConfigPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/SetVideoSeekConfigPost

func (*Cdnv1) SetVideoSeekConfigPostRequest ¶

func (c *Cdnv1) SetVideoSeekConfigPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetVideoSeekConfigPostRequest generates a "ksc/request.Request" representing the client's request for the SetVideoSeekConfigPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetVideoSeekConfigPost for more information on using the SetVideoSeekConfigPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetVideoSeekConfigPostRequest method.
req, resp := client.SetVideoSeekConfigPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) SetVideoSeekConfigPostWithContext ¶

func (c *Cdnv1) SetVideoSeekConfigPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetVideoSeekConfigPostWithContext is the same as SetVideoSeekConfigPost with the addition of the ability to pass a context and additional request options.

See SetVideoSeekConfigPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) StartStopCdnDomainGet ¶

func (c *Cdnv1) StartStopCdnDomainGet(input *map[string]interface{}) (*map[string]interface{}, error)

StartStopCdnDomainGet API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation StartStopCdnDomainGet for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/StartStopCdnDomainGet

func (*Cdnv1) StartStopCdnDomainGetRequest ¶

func (c *Cdnv1) StartStopCdnDomainGetRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

StartStopCdnDomainGetRequest generates a "ksc/request.Request" representing the client's request for the StartStopCdnDomainGet operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See StartStopCdnDomainGet for more information on using the StartStopCdnDomainGet API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the StartStopCdnDomainGetRequest method.
req, resp := client.StartStopCdnDomainGetRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) StartStopCdnDomainGetWithContext ¶

func (c *Cdnv1) StartStopCdnDomainGetWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

StartStopCdnDomainGetWithContext is the same as StartStopCdnDomainGet with the addition of the ability to pass a context and additional request options.

See StartStopCdnDomainGet for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Cdnv1) StartStopCdnDomainPost ¶

func (c *Cdnv1) StartStopCdnDomainPost(input *map[string]interface{}) (*map[string]interface{}, error)

StartStopCdnDomainPost API operation for cdnv1.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for cdnv1's API operation StartStopCdnDomainPost for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/cdn-2016-09-01/StartStopCdnDomainPost

func (*Cdnv1) StartStopCdnDomainPostRequest ¶

func (c *Cdnv1) StartStopCdnDomainPostRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

StartStopCdnDomainPostRequest generates a "ksc/request.Request" representing the client's request for the StartStopCdnDomainPost operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See StartStopCdnDomainPost for more information on using the StartStopCdnDomainPost API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the StartStopCdnDomainPostRequest method.
req, resp := client.StartStopCdnDomainPostRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Cdnv1) StartStopCdnDomainPostWithContext ¶

func (c *Cdnv1) StartStopCdnDomainPostWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

StartStopCdnDomainPostWithContext is the same as StartStopCdnDomainPost with the addition of the ability to pass a context and additional request options.

See StartStopCdnDomainPost for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
cdnv1iface Package cdnv1iface provides an interface to enable mocking the cdnv1 service client for testing your code.	Package cdnv1iface provides an interface to enable mocking the cdnv1 service client for testing your code.

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL