ActionDomain.go

// Code generated by msgraph.go/gen DO NOT EDIT.

package msgraph

import (
	"context"
	"fmt"
	"io/ioutil"
	"net/http"

	"github.com/BenHagueNZ/msgraph.go/jsonx"
)

// DomainForceDeleteRequestParameter undocumented
type DomainForceDeleteRequestParameter struct {
	// DisableUserAccounts undocumented
	DisableUserAccounts *bool `json:"disableUserAccounts,omitempty"`
}

// DomainPromoteRequestParameter undocumented
type DomainPromoteRequestParameter struct {
}

// DomainVerifyRequestParameter undocumented
type DomainVerifyRequestParameter struct {
}

// DomainNameReferences returns request builder for DirectoryObject collection
func (b *DomainRequestBuilder) DomainNameReferences() *DomainDomainNameReferencesCollectionRequestBuilder {
	bb := &DomainDomainNameReferencesCollectionRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/domainNameReferences"
	return bb
}

// DomainDomainNameReferencesCollectionRequestBuilder is request builder for DirectoryObject collection rcn
type DomainDomainNameReferencesCollectionRequestBuilder struct{ BaseRequestBuilder }

// Request returns request for DirectoryObject collection
func (b *DomainDomainNameReferencesCollectionRequestBuilder) Request() *DomainDomainNameReferencesCollectionRequest {
	return &DomainDomainNameReferencesCollectionRequest{
		BaseRequest: BaseRequest{baseURL: b.baseURL, client: b.client},
	}
}

// ID returns request builder for DirectoryObject item
func (b *DomainDomainNameReferencesCollectionRequestBuilder) ID(id string) *DirectoryObjectRequestBuilder {
	bb := &DirectoryObjectRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/" + id
	return bb
}

// DomainDomainNameReferencesCollectionRequest is request for DirectoryObject collection
type DomainDomainNameReferencesCollectionRequest struct{ BaseRequest }

// Paging perfoms paging operation for DirectoryObject collection
func (r *DomainDomainNameReferencesCollectionRequest) Paging(ctx context.Context, method, path string, obj interface{}, n int) ([]DirectoryObject, error) {
	req, err := r.NewJSONRequest(method, path, obj)
	if err != nil {
		return nil, err
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}
	res, err := r.client.Do(req)
	if err != nil {
		return nil, err
	}
	var values []DirectoryObject
	for {
		if res.StatusCode != http.StatusOK {
			b, _ := ioutil.ReadAll(res.Body)
			res.Body.Close()
			errRes := &ErrorResponse{Response: res}
			err := jsonx.Unmarshal(b, errRes)
			if err != nil {
				return nil, fmt.Errorf("%s: %s", res.Status, string(b))
			}
			return nil, errRes
		}
		var (
			paging Paging
			value  []DirectoryObject
		)
		err := jsonx.NewDecoder(res.Body).Decode(&paging)
		res.Body.Close()
		if err != nil {
			return nil, err
		}
		err = jsonx.Unmarshal(paging.Value, &value)
		if err != nil {
			return nil, err
		}
		values = append(values, value...)
		if n >= 0 {
			n--
		}
		if n == 0 || len(paging.NextLink) == 0 {
			return values, nil
		}
		req, err = http.NewRequest("GET", paging.NextLink, nil)
		if ctx != nil {
			req = req.WithContext(ctx)
		}
		res, err = r.client.Do(req)
		if err != nil {
			return nil, err
		}
	}
}

// GetN performs GET request for DirectoryObject collection, max N pages
func (r *DomainDomainNameReferencesCollectionRequest) GetN(ctx context.Context, n int) ([]DirectoryObject, error) {
	var query string
	if r.query != nil {
		query = "?" + r.query.Encode()
	}
	return r.Paging(ctx, "GET", query, nil, n)
}

// Get performs GET request for DirectoryObject collection
func (r *DomainDomainNameReferencesCollectionRequest) Get(ctx context.Context) ([]DirectoryObject, error) {
	return r.GetN(ctx, 0)
}

// Add performs POST request for DirectoryObject collection
func (r *DomainDomainNameReferencesCollectionRequest) Add(ctx context.Context, reqObj *DirectoryObject) (resObj *DirectoryObject, err error) {
	err = r.JSONRequest(ctx, "POST", "", reqObj, &resObj)
	return
}

// FederationConfiguration returns request builder for InternalDomainFederation collection
func (b *DomainRequestBuilder) FederationConfiguration() *DomainFederationConfigurationCollectionRequestBuilder {
	bb := &DomainFederationConfigurationCollectionRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/federationConfiguration"
	return bb
}

// DomainFederationConfigurationCollectionRequestBuilder is request builder for InternalDomainFederation collection rcn
type DomainFederationConfigurationCollectionRequestBuilder struct{ BaseRequestBuilder }

// Request returns request for InternalDomainFederation collection
func (b *DomainFederationConfigurationCollectionRequestBuilder) Request() *DomainFederationConfigurationCollectionRequest {
	return &DomainFederationConfigurationCollectionRequest{
		BaseRequest: BaseRequest{baseURL: b.baseURL, client: b.client},
	}
}

// ID returns request builder for InternalDomainFederation item
func (b *DomainFederationConfigurationCollectionRequestBuilder) ID(id string) *InternalDomainFederationRequestBuilder {
	bb := &InternalDomainFederationRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/" + id
	return bb
}

// DomainFederationConfigurationCollectionRequest is request for InternalDomainFederation collection
type DomainFederationConfigurationCollectionRequest struct{ BaseRequest }

// Paging perfoms paging operation for InternalDomainFederation collection
func (r *DomainFederationConfigurationCollectionRequest) Paging(ctx context.Context, method, path string, obj interface{}, n int) ([]InternalDomainFederation, error) {
	req, err := r.NewJSONRequest(method, path, obj)
	if err != nil {
		return nil, err
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}
	res, err := r.client.Do(req)
	if err != nil {
		return nil, err
	}
	var values []InternalDomainFederation
	for {
		if res.StatusCode != http.StatusOK {
			b, _ := ioutil.ReadAll(res.Body)
			res.Body.Close()
			errRes := &ErrorResponse{Response: res}
			err := jsonx.Unmarshal(b, errRes)
			if err != nil {
				return nil, fmt.Errorf("%s: %s", res.Status, string(b))
			}
			return nil, errRes
		}
		var (
			paging Paging
			value  []InternalDomainFederation
		)
		err := jsonx.NewDecoder(res.Body).Decode(&paging)
		res.Body.Close()
		if err != nil {
			return nil, err
		}
		err = jsonx.Unmarshal(paging.Value, &value)
		if err != nil {
			return nil, err
		}
		values = append(values, value...)
		if n >= 0 {
			n--
		}
		if n == 0 || len(paging.NextLink) == 0 {
			return values, nil
		}
		req, err = http.NewRequest("GET", paging.NextLink, nil)
		if ctx != nil {
			req = req.WithContext(ctx)
		}
		res, err = r.client.Do(req)
		if err != nil {
			return nil, err
		}
	}
}

// GetN performs GET request for InternalDomainFederation collection, max N pages
func (r *DomainFederationConfigurationCollectionRequest) GetN(ctx context.Context, n int) ([]InternalDomainFederation, error) {
	var query string
	if r.query != nil {
		query = "?" + r.query.Encode()
	}
	return r.Paging(ctx, "GET", query, nil, n)
}

// Get performs GET request for InternalDomainFederation collection
func (r *DomainFederationConfigurationCollectionRequest) Get(ctx context.Context) ([]InternalDomainFederation, error) {
	return r.GetN(ctx, 0)
}

// Add performs POST request for InternalDomainFederation collection
func (r *DomainFederationConfigurationCollectionRequest) Add(ctx context.Context, reqObj *InternalDomainFederation) (resObj *InternalDomainFederation, err error) {
	err = r.JSONRequest(ctx, "POST", "", reqObj, &resObj)
	return
}

// ServiceConfigurationRecords returns request builder for DomainDnsRecord collection
func (b *DomainRequestBuilder) ServiceConfigurationRecords() *DomainServiceConfigurationRecordsCollectionRequestBuilder {
	bb := &DomainServiceConfigurationRecordsCollectionRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/serviceConfigurationRecords"
	return bb
}

// DomainServiceConfigurationRecordsCollectionRequestBuilder is request builder for DomainDnsRecord collection rcn
type DomainServiceConfigurationRecordsCollectionRequestBuilder struct{ BaseRequestBuilder }

// Request returns request for DomainDnsRecord collection
func (b *DomainServiceConfigurationRecordsCollectionRequestBuilder) Request() *DomainServiceConfigurationRecordsCollectionRequest {
	return &DomainServiceConfigurationRecordsCollectionRequest{
		BaseRequest: BaseRequest{baseURL: b.baseURL, client: b.client},
	}
}

// ID returns request builder for DomainDnsRecord item
func (b *DomainServiceConfigurationRecordsCollectionRequestBuilder) ID(id string) *DomainDnsRecordRequestBuilder {
	bb := &DomainDnsRecordRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/" + id
	return bb
}

// DomainServiceConfigurationRecordsCollectionRequest is request for DomainDnsRecord collection
type DomainServiceConfigurationRecordsCollectionRequest struct{ BaseRequest }

// Paging perfoms paging operation for DomainDnsRecord collection
func (r *DomainServiceConfigurationRecordsCollectionRequest) Paging(ctx context.Context, method, path string, obj interface{}, n int) ([]DomainDnsRecord, error) {
	req, err := r.NewJSONRequest(method, path, obj)
	if err != nil {
		return nil, err
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}
	res, err := r.client.Do(req)
	if err != nil {
		return nil, err
	}
	var values []DomainDnsRecord
	for {
		if res.StatusCode != http.StatusOK {
			b, _ := ioutil.ReadAll(res.Body)
			res.Body.Close()
			errRes := &ErrorResponse{Response: res}
			err := jsonx.Unmarshal(b, errRes)
			if err != nil {
				return nil, fmt.Errorf("%s: %s", res.Status, string(b))
			}
			return nil, errRes
		}
		var (
			paging Paging
			value  []DomainDnsRecord
		)
		err := jsonx.NewDecoder(res.Body).Decode(&paging)
		res.Body.Close()
		if err != nil {
			return nil, err
		}
		err = jsonx.Unmarshal(paging.Value, &value)
		if err != nil {
			return nil, err
		}
		values = append(values, value...)
		if n >= 0 {
			n--
		}
		if n == 0 || len(paging.NextLink) == 0 {
			return values, nil
		}
		req, err = http.NewRequest("GET", paging.NextLink, nil)
		if ctx != nil {
			req = req.WithContext(ctx)
		}
		res, err = r.client.Do(req)
		if err != nil {
			return nil, err
		}
	}
}

// GetN performs GET request for DomainDnsRecord collection, max N pages
func (r *DomainServiceConfigurationRecordsCollectionRequest) GetN(ctx context.Context, n int) ([]DomainDnsRecord, error) {
	var query string
	if r.query != nil {
		query = "?" + r.query.Encode()
	}
	return r.Paging(ctx, "GET", query, nil, n)
}

// Get performs GET request for DomainDnsRecord collection
func (r *DomainServiceConfigurationRecordsCollectionRequest) Get(ctx context.Context) ([]DomainDnsRecord, error) {
	return r.GetN(ctx, 0)
}

// Add performs POST request for DomainDnsRecord collection
func (r *DomainServiceConfigurationRecordsCollectionRequest) Add(ctx context.Context, reqObj *DomainDnsRecord) (resObj *DomainDnsRecord, err error) {
	err = r.JSONRequest(ctx, "POST", "", reqObj, &resObj)
	return
}

// VerificationDnsRecords returns request builder for DomainDnsRecord collection
func (b *DomainRequestBuilder) VerificationDnsRecords() *DomainVerificationDnsRecordsCollectionRequestBuilder {
	bb := &DomainVerificationDnsRecordsCollectionRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/verificationDnsRecords"
	return bb
}

// DomainVerificationDnsRecordsCollectionRequestBuilder is request builder for DomainDnsRecord collection rcn
type DomainVerificationDnsRecordsCollectionRequestBuilder struct{ BaseRequestBuilder }

// Request returns request for DomainDnsRecord collection
func (b *DomainVerificationDnsRecordsCollectionRequestBuilder) Request() *DomainVerificationDnsRecordsCollectionRequest {
	return &DomainVerificationDnsRecordsCollectionRequest{
		BaseRequest: BaseRequest{baseURL: b.baseURL, client: b.client},
	}
}

// ID returns request builder for DomainDnsRecord item
func (b *DomainVerificationDnsRecordsCollectionRequestBuilder) ID(id string) *DomainDnsRecordRequestBuilder {
	bb := &DomainDnsRecordRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/" + id
	return bb
}

// DomainVerificationDnsRecordsCollectionRequest is request for DomainDnsRecord collection
type DomainVerificationDnsRecordsCollectionRequest struct{ BaseRequest }

// Paging perfoms paging operation for DomainDnsRecord collection
func (r *DomainVerificationDnsRecordsCollectionRequest) Paging(ctx context.Context, method, path string, obj interface{}, n int) ([]DomainDnsRecord, error) {
	req, err := r.NewJSONRequest(method, path, obj)
	if err != nil {
		return nil, err
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}
	res, err := r.client.Do(req)
	if err != nil {
		return nil, err
	}
	var values []DomainDnsRecord
	for {
		if res.StatusCode != http.StatusOK {
			b, _ := ioutil.ReadAll(res.Body)
			res.Body.Close()
			errRes := &ErrorResponse{Response: res}
			err := jsonx.Unmarshal(b, errRes)
			if err != nil {
				return nil, fmt.Errorf("%s: %s", res.Status, string(b))
			}
			return nil, errRes
		}
		var (
			paging Paging
			value  []DomainDnsRecord
		)
		err := jsonx.NewDecoder(res.Body).Decode(&paging)
		res.Body.Close()
		if err != nil {
			return nil, err
		}
		err = jsonx.Unmarshal(paging.Value, &value)
		if err != nil {
			return nil, err
		}
		values = append(values, value...)
		if n >= 0 {
			n--
		}
		if n == 0 || len(paging.NextLink) == 0 {
			return values, nil
		}
		req, err = http.NewRequest("GET", paging.NextLink, nil)
		if ctx != nil {
			req = req.WithContext(ctx)
		}
		res, err = r.client.Do(req)
		if err != nil {
			return nil, err
		}
	}
}

// GetN performs GET request for DomainDnsRecord collection, max N pages
func (r *DomainVerificationDnsRecordsCollectionRequest) GetN(ctx context.Context, n int) ([]DomainDnsRecord, error) {
	var query string
	if r.query != nil {
		query = "?" + r.query.Encode()
	}
	return r.Paging(ctx, "GET", query, nil, n)
}

// Get performs GET request for DomainDnsRecord collection
func (r *DomainVerificationDnsRecordsCollectionRequest) Get(ctx context.Context) ([]DomainDnsRecord, error) {
	return r.GetN(ctx, 0)
}

// Add performs POST request for DomainDnsRecord collection
func (r *DomainVerificationDnsRecordsCollectionRequest) Add(ctx context.Context, reqObj *DomainDnsRecord) (resObj *DomainDnsRecord, err error) {
	err = r.JSONRequest(ctx, "POST", "", reqObj, &resObj)
	return
}

// Entity is navigation property rn
func (b *DomainRequestBuilder) Entity() *EntityRequestBuilder {
	bb := &EntityRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/Entity"
	return bb
}

// DomainDnsCnameRecord returns request builder for DomainDnsCnameRecord collection
func (b *DomainServiceConfigurationRecordsCollectionRequestBuilder) DomainDnsCnameRecord() *DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequestBuilder {
	bb := &DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/"
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequestBuilder is request builder for DomainDnsCnameRecord collection rcn
type DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequestBuilder struct{ BaseRequestBuilder }

// Request returns request for DomainDnsCnameRecord collection
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequestBuilder) Request() *DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequest {
	return &DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequest{
		BaseRequest: BaseRequest{baseURL: b.baseURL, client: b.client},
	}
}

// ID returns request builder for DomainDnsCnameRecord item
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequestBuilder) ID(id string) *DomainDnsCnameRecordRequestBuilder {
	bb := &DomainDnsCnameRecordRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/" + id
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequest is request for DomainDnsCnameRecord collection
type DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequest struct{ BaseRequest }

// Paging perfoms paging operation for DomainDnsCnameRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequest) Paging(ctx context.Context, method, path string, obj interface{}, n int) ([]DomainDnsCnameRecord, error) {
	req, err := r.NewJSONRequest(method, path, obj)
	if err != nil {
		return nil, err
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}
	res, err := r.client.Do(req)
	if err != nil {
		return nil, err
	}
	var values []DomainDnsCnameRecord
	for {
		if res.StatusCode != http.StatusOK {
			b, _ := ioutil.ReadAll(res.Body)
			res.Body.Close()
			errRes := &ErrorResponse{Response: res}
			err := jsonx.Unmarshal(b, errRes)
			if err != nil {
				return nil, fmt.Errorf("%s: %s", res.Status, string(b))
			}
			return nil, errRes
		}
		var (
			paging Paging
			value  []DomainDnsCnameRecord
		)
		err := jsonx.NewDecoder(res.Body).Decode(&paging)
		res.Body.Close()
		if err != nil {
			return nil, err
		}
		err = jsonx.Unmarshal(paging.Value, &value)
		if err != nil {
			return nil, err
		}
		values = append(values, value...)
		if n >= 0 {
			n--
		}
		if n == 0 || len(paging.NextLink) == 0 {
			return values, nil
		}
		req, err = http.NewRequest("GET", paging.NextLink, nil)
		if ctx != nil {
			req = req.WithContext(ctx)
		}
		res, err = r.client.Do(req)
		if err != nil {
			return nil, err
		}
	}
}

// GetN performs GET request for DomainDnsCnameRecord collection, max N pages
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequest) GetN(ctx context.Context, n int) ([]DomainDnsCnameRecord, error) {
	var query string
	if r.query != nil {
		query = "?" + r.query.Encode()
	}
	return r.Paging(ctx, "GET", query, nil, n)
}

// Get performs GET request for DomainDnsCnameRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequest) Get(ctx context.Context) ([]DomainDnsCnameRecord, error) {
	return r.GetN(ctx, 0)
}

// Add performs POST request for DomainDnsCnameRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsCnameRecordCollectionRequest) Add(ctx context.Context, reqObj *DomainDnsCnameRecord) (resObj *DomainDnsCnameRecord, err error) {
	err = r.JSONRequest(ctx, "POST", "", reqObj, &resObj)
	return
}

// DomainDnsMxRecord returns request builder for DomainDnsMxRecord collection
func (b *DomainServiceConfigurationRecordsCollectionRequestBuilder) DomainDnsMxRecord() *DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequestBuilder {
	bb := &DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/"
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequestBuilder is request builder for DomainDnsMxRecord collection rcn
type DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequestBuilder struct{ BaseRequestBuilder }

// Request returns request for DomainDnsMxRecord collection
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequestBuilder) Request() *DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequest {
	return &DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequest{
		BaseRequest: BaseRequest{baseURL: b.baseURL, client: b.client},
	}
}

// ID returns request builder for DomainDnsMxRecord item
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequestBuilder) ID(id string) *DomainDnsMxRecordRequestBuilder {
	bb := &DomainDnsMxRecordRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/" + id
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequest is request for DomainDnsMxRecord collection
type DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequest struct{ BaseRequest }

// Paging perfoms paging operation for DomainDnsMxRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequest) Paging(ctx context.Context, method, path string, obj interface{}, n int) ([]DomainDnsMxRecord, error) {
	req, err := r.NewJSONRequest(method, path, obj)
	if err != nil {
		return nil, err
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}
	res, err := r.client.Do(req)
	if err != nil {
		return nil, err
	}
	var values []DomainDnsMxRecord
	for {
		if res.StatusCode != http.StatusOK {
			b, _ := ioutil.ReadAll(res.Body)
			res.Body.Close()
			errRes := &ErrorResponse{Response: res}
			err := jsonx.Unmarshal(b, errRes)
			if err != nil {
				return nil, fmt.Errorf("%s: %s", res.Status, string(b))
			}
			return nil, errRes
		}
		var (
			paging Paging
			value  []DomainDnsMxRecord
		)
		err := jsonx.NewDecoder(res.Body).Decode(&paging)
		res.Body.Close()
		if err != nil {
			return nil, err
		}
		err = jsonx.Unmarshal(paging.Value, &value)
		if err != nil {
			return nil, err
		}
		values = append(values, value...)
		if n >= 0 {
			n--
		}
		if n == 0 || len(paging.NextLink) == 0 {
			return values, nil
		}
		req, err = http.NewRequest("GET", paging.NextLink, nil)
		if ctx != nil {
			req = req.WithContext(ctx)
		}
		res, err = r.client.Do(req)
		if err != nil {
			return nil, err
		}
	}
}

// GetN performs GET request for DomainDnsMxRecord collection, max N pages
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequest) GetN(ctx context.Context, n int) ([]DomainDnsMxRecord, error) {
	var query string
	if r.query != nil {
		query = "?" + r.query.Encode()
	}
	return r.Paging(ctx, "GET", query, nil, n)
}

// Get performs GET request for DomainDnsMxRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequest) Get(ctx context.Context) ([]DomainDnsMxRecord, error) {
	return r.GetN(ctx, 0)
}

// Add performs POST request for DomainDnsMxRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsMxRecordCollectionRequest) Add(ctx context.Context, reqObj *DomainDnsMxRecord) (resObj *DomainDnsMxRecord, err error) {
	err = r.JSONRequest(ctx, "POST", "", reqObj, &resObj)
	return
}

// DomainDnsSrvRecord returns request builder for DomainDnsSrvRecord collection
func (b *DomainServiceConfigurationRecordsCollectionRequestBuilder) DomainDnsSrvRecord() *DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequestBuilder {
	bb := &DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/"
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequestBuilder is request builder for DomainDnsSrvRecord collection rcn
type DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequestBuilder struct{ BaseRequestBuilder }

// Request returns request for DomainDnsSrvRecord collection
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequestBuilder) Request() *DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequest {
	return &DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequest{
		BaseRequest: BaseRequest{baseURL: b.baseURL, client: b.client},
	}
}

// ID returns request builder for DomainDnsSrvRecord item
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequestBuilder) ID(id string) *DomainDnsSrvRecordRequestBuilder {
	bb := &DomainDnsSrvRecordRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/" + id
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequest is request for DomainDnsSrvRecord collection
type DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequest struct{ BaseRequest }

// Paging perfoms paging operation for DomainDnsSrvRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequest) Paging(ctx context.Context, method, path string, obj interface{}, n int) ([]DomainDnsSrvRecord, error) {
	req, err := r.NewJSONRequest(method, path, obj)
	if err != nil {
		return nil, err
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}
	res, err := r.client.Do(req)
	if err != nil {
		return nil, err
	}
	var values []DomainDnsSrvRecord
	for {
		if res.StatusCode != http.StatusOK {
			b, _ := ioutil.ReadAll(res.Body)
			res.Body.Close()
			errRes := &ErrorResponse{Response: res}
			err := jsonx.Unmarshal(b, errRes)
			if err != nil {
				return nil, fmt.Errorf("%s: %s", res.Status, string(b))
			}
			return nil, errRes
		}
		var (
			paging Paging
			value  []DomainDnsSrvRecord
		)
		err := jsonx.NewDecoder(res.Body).Decode(&paging)
		res.Body.Close()
		if err != nil {
			return nil, err
		}
		err = jsonx.Unmarshal(paging.Value, &value)
		if err != nil {
			return nil, err
		}
		values = append(values, value...)
		if n >= 0 {
			n--
		}
		if n == 0 || len(paging.NextLink) == 0 {
			return values, nil
		}
		req, err = http.NewRequest("GET", paging.NextLink, nil)
		if ctx != nil {
			req = req.WithContext(ctx)
		}
		res, err = r.client.Do(req)
		if err != nil {
			return nil, err
		}
	}
}

// GetN performs GET request for DomainDnsSrvRecord collection, max N pages
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequest) GetN(ctx context.Context, n int) ([]DomainDnsSrvRecord, error) {
	var query string
	if r.query != nil {
		query = "?" + r.query.Encode()
	}
	return r.Paging(ctx, "GET", query, nil, n)
}

// Get performs GET request for DomainDnsSrvRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequest) Get(ctx context.Context) ([]DomainDnsSrvRecord, error) {
	return r.GetN(ctx, 0)
}

// Add performs POST request for DomainDnsSrvRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsSrvRecordCollectionRequest) Add(ctx context.Context, reqObj *DomainDnsSrvRecord) (resObj *DomainDnsSrvRecord, err error) {
	err = r.JSONRequest(ctx, "POST", "", reqObj, &resObj)
	return
}

// DomainDnsTxtRecord returns request builder for DomainDnsTxtRecord collection
func (b *DomainServiceConfigurationRecordsCollectionRequestBuilder) DomainDnsTxtRecord() *DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequestBuilder {
	bb := &DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/"
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequestBuilder is request builder for DomainDnsTxtRecord collection rcn
type DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequestBuilder struct{ BaseRequestBuilder }

// Request returns request for DomainDnsTxtRecord collection
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequestBuilder) Request() *DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequest {
	return &DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequest{
		BaseRequest: BaseRequest{baseURL: b.baseURL, client: b.client},
	}
}

// ID returns request builder for DomainDnsTxtRecord item
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequestBuilder) ID(id string) *DomainDnsTxtRecordRequestBuilder {
	bb := &DomainDnsTxtRecordRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/" + id
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequest is request for DomainDnsTxtRecord collection
type DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequest struct{ BaseRequest }

// Paging perfoms paging operation for DomainDnsTxtRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequest) Paging(ctx context.Context, method, path string, obj interface{}, n int) ([]DomainDnsTxtRecord, error) {
	req, err := r.NewJSONRequest(method, path, obj)
	if err != nil {
		return nil, err
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}
	res, err := r.client.Do(req)
	if err != nil {
		return nil, err
	}
	var values []DomainDnsTxtRecord
	for {
		if res.StatusCode != http.StatusOK {
			b, _ := ioutil.ReadAll(res.Body)
			res.Body.Close()
			errRes := &ErrorResponse{Response: res}
			err := jsonx.Unmarshal(b, errRes)
			if err != nil {
				return nil, fmt.Errorf("%s: %s", res.Status, string(b))
			}
			return nil, errRes
		}
		var (
			paging Paging
			value  []DomainDnsTxtRecord
		)
		err := jsonx.NewDecoder(res.Body).Decode(&paging)
		res.Body.Close()
		if err != nil {
			return nil, err
		}
		err = jsonx.Unmarshal(paging.Value, &value)
		if err != nil {
			return nil, err
		}
		values = append(values, value...)
		if n >= 0 {
			n--
		}
		if n == 0 || len(paging.NextLink) == 0 {
			return values, nil
		}
		req, err = http.NewRequest("GET", paging.NextLink, nil)
		if ctx != nil {
			req = req.WithContext(ctx)
		}
		res, err = r.client.Do(req)
		if err != nil {
			return nil, err
		}
	}
}

// GetN performs GET request for DomainDnsTxtRecord collection, max N pages
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequest) GetN(ctx context.Context, n int) ([]DomainDnsTxtRecord, error) {
	var query string
	if r.query != nil {
		query = "?" + r.query.Encode()
	}
	return r.Paging(ctx, "GET", query, nil, n)
}

// Get performs GET request for DomainDnsTxtRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequest) Get(ctx context.Context) ([]DomainDnsTxtRecord, error) {
	return r.GetN(ctx, 0)
}

// Add performs POST request for DomainDnsTxtRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsTxtRecordCollectionRequest) Add(ctx context.Context, reqObj *DomainDnsTxtRecord) (resObj *DomainDnsTxtRecord, err error) {
	err = r.JSONRequest(ctx, "POST", "", reqObj, &resObj)
	return
}

// DomainDnsUnavailableRecord returns request builder for DomainDnsUnavailableRecord collection
func (b *DomainServiceConfigurationRecordsCollectionRequestBuilder) DomainDnsUnavailableRecord() *DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequestBuilder {
	bb := &DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/"
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequestBuilder is request builder for DomainDnsUnavailableRecord collection rcn
type DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequestBuilder struct{ BaseRequestBuilder }

// Request returns request for DomainDnsUnavailableRecord collection
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequestBuilder) Request() *DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequest {
	return &DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequest{
		BaseRequest: BaseRequest{baseURL: b.baseURL, client: b.client},
	}
}

// ID returns request builder for DomainDnsUnavailableRecord item
func (b *DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequestBuilder) ID(id string) *DomainDnsUnavailableRecordRequestBuilder {
	bb := &DomainDnsUnavailableRecordRequestBuilder{BaseRequestBuilder: b.BaseRequestBuilder}
	bb.baseURL += "/" + id
	return bb
}

// DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequest is request for DomainDnsUnavailableRecord collection
type DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequest struct{ BaseRequest }

// Paging perfoms paging operation for DomainDnsUnavailableRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequest) Paging(ctx context.Context, method, path string, obj interface{}, n int) ([]DomainDnsUnavailableRecord, error) {
	req, err := r.NewJSONRequest(method, path, obj)
	if err != nil {
		return nil, err
	}
	if ctx != nil {
		req = req.WithContext(ctx)
	}
	res, err := r.client.Do(req)
	if err != nil {
		return nil, err
	}
	var values []DomainDnsUnavailableRecord
	for {
		if res.StatusCode != http.StatusOK {
			b, _ := ioutil.ReadAll(res.Body)
			res.Body.Close()
			errRes := &ErrorResponse{Response: res}
			err := jsonx.Unmarshal(b, errRes)
			if err != nil {
				return nil, fmt.Errorf("%s: %s", res.Status, string(b))
			}
			return nil, errRes
		}
		var (
			paging Paging
			value  []DomainDnsUnavailableRecord
		)
		err := jsonx.NewDecoder(res.Body).Decode(&paging)
		res.Body.Close()
		if err != nil {
			return nil, err
		}
		err = jsonx.Unmarshal(paging.Value, &value)
		if err != nil {
			return nil, err
		}
		values = append(values, value...)
		if n >= 0 {
			n--
		}
		if n == 0 || len(paging.NextLink) == 0 {
			return values, nil
		}
		req, err = http.NewRequest("GET", paging.NextLink, nil)
		if ctx != nil {
			req = req.WithContext(ctx)
		}
		res, err = r.client.Do(req)
		if err != nil {
			return nil, err
		}
	}
}

// GetN performs GET request for DomainDnsUnavailableRecord collection, max N pages
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequest) GetN(ctx context.Context, n int) ([]DomainDnsUnavailableRecord, error) {
	var query string
	if r.query != nil {
		query = "?" + r.query.Encode()
	}
	return r.Paging(ctx, "GET", query, nil, n)
}

// Get performs GET request for DomainDnsUnavailableRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequest) Get(ctx context.Context) ([]DomainDnsUnavailableRecord, error) {
	return r.GetN(ctx, 0)
}

// Add performs POST request for DomainDnsUnavailableRecord collection
func (r *DomainServiceConfigurationRecordsCollectionDomainDnsUnavailableRecordCollectionRequest) Add(ctx context.Context, reqObj *DomainDnsUnavailableRecord) (resObj *DomainDnsUnavailableRecord, err error) {
	err = r.JSONRequest(ctx, "POST", "", reqObj, &resObj)
	return
}