api_email_forwarding.go

/*
ArvanCloud CDN Services

No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

API version: 4.99.2
*/

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package r1cdn

import (
	"bytes"
	"context"
	"io"
	"net/http"
	"net/url"
	"strings"
)


// EmailForwardingApiService EmailForwardingApi service
type EmailForwardingApiService service

type ApiEmailForwardingsActivateRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
}

func (r ApiEmailForwardingsActivateRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsActivateExecute(r)
}

/*
EmailForwardingsActivate Activate email forwarding

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @return ApiEmailForwardingsActivateRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsActivate(ctx context.Context, domain string) ApiEmailForwardingsActivateRequest {
	return ApiEmailForwardingsActivateRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsActivateExecute(r ApiEmailForwardingsActivateRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsActivate")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/activate"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 409 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsAliasesDestroyRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	emailForwardingAliasId string
}

func (r ApiEmailForwardingsAliasesDestroyRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsAliasesDestroyExecute(r)
}

/*
EmailForwardingsAliasesDestroy Delete an alias

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @param emailForwardingAliasId Email forwarding alias id
 @return ApiEmailForwardingsAliasesDestroyRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsAliasesDestroy(ctx context.Context, domain string, emailForwardingId string, emailForwardingAliasId string) ApiEmailForwardingsAliasesDestroyRequest {
	return ApiEmailForwardingsAliasesDestroyRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
		emailForwardingAliasId: emailForwardingAliasId,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsAliasesDestroyExecute(r ApiEmailForwardingsAliasesDestroyRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodDelete
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsAliasesDestroy")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/aliases/{emailForwardingAliasId}"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingAliasId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingAliasId, "emailForwardingAliasId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsAliasesIndexRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	perPage *int32
	page *int32
}

// Set how many items returned per page
func (r ApiEmailForwardingsAliasesIndexRequest) PerPage(perPage int32) ApiEmailForwardingsAliasesIndexRequest {
	r.perPage = &perPage
	return r
}

// Set the desired page number
func (r ApiEmailForwardingsAliasesIndexRequest) Page(page int32) ApiEmailForwardingsAliasesIndexRequest {
	r.page = &page
	return r
}

func (r ApiEmailForwardingsAliasesIndexRequest) Execute() (*EmailForwardingAliasesListData, *http.Response, error) {
	return r.ApiService.EmailForwardingsAliasesIndexExecute(r)
}

/*
EmailForwardingsAliasesIndex List of email forwarding aliases for given domain

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @return ApiEmailForwardingsAliasesIndexRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsAliasesIndex(ctx context.Context, domain string, emailForwardingId string) ApiEmailForwardingsAliasesIndexRequest {
	return ApiEmailForwardingsAliasesIndexRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
	}
}

// Execute executes the request
//  @return EmailForwardingAliasesListData
func (a *EmailForwardingApiService) EmailForwardingsAliasesIndexExecute(r ApiEmailForwardingsAliasesIndexRequest) (*EmailForwardingAliasesListData, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *EmailForwardingAliasesListData
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsAliasesIndex")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/aliases"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.perPage != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "per_page", r.perPage, "")
	}
	if r.page != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsAliasesStoreRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	emailForwardingAliasesStore *EmailForwardingAliasesStore
}

func (r ApiEmailForwardingsAliasesStoreRequest) EmailForwardingAliasesStore(emailForwardingAliasesStore EmailForwardingAliasesStore) ApiEmailForwardingsAliasesStoreRequest {
	r.emailForwardingAliasesStore = &emailForwardingAliasesStore
	return r
}

func (r ApiEmailForwardingsAliasesStoreRequest) Execute() (*EmailForwardingsAliasesStore201Response, *http.Response, error) {
	return r.ApiService.EmailForwardingsAliasesStoreExecute(r)
}

/*
EmailForwardingsAliasesStore Create new alias

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @return ApiEmailForwardingsAliasesStoreRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsAliasesStore(ctx context.Context, domain string, emailForwardingId string) ApiEmailForwardingsAliasesStoreRequest {
	return ApiEmailForwardingsAliasesStoreRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
	}
}

// Execute executes the request
//  @return EmailForwardingsAliasesStore201Response
func (a *EmailForwardingApiService) EmailForwardingsAliasesStoreExecute(r ApiEmailForwardingsAliasesStoreRequest) (*EmailForwardingsAliasesStore201Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *EmailForwardingsAliasesStore201Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsAliasesStore")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/aliases"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.emailForwardingAliasesStore
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsAliasesToggleActivationRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	emailForwardingAliasId string
	emailForwardingAliasesToggleActivation *EmailForwardingAliasesToggleActivation
}

func (r ApiEmailForwardingsAliasesToggleActivationRequest) EmailForwardingAliasesToggleActivation(emailForwardingAliasesToggleActivation EmailForwardingAliasesToggleActivation) ApiEmailForwardingsAliasesToggleActivationRequest {
	r.emailForwardingAliasesToggleActivation = &emailForwardingAliasesToggleActivation
	return r
}

func (r ApiEmailForwardingsAliasesToggleActivationRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsAliasesToggleActivationExecute(r)
}

/*
EmailForwardingsAliasesToggleActivation Toggle alias activation

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @param emailForwardingAliasId Email forwarding alias id
 @return ApiEmailForwardingsAliasesToggleActivationRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsAliasesToggleActivation(ctx context.Context, domain string, emailForwardingId string, emailForwardingAliasId string) ApiEmailForwardingsAliasesToggleActivationRequest {
	return ApiEmailForwardingsAliasesToggleActivationRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
		emailForwardingAliasId: emailForwardingAliasId,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsAliasesToggleActivationExecute(r ApiEmailForwardingsAliasesToggleActivationRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPatch
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsAliasesToggleActivation")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/aliases/{emailForwardingAliasId}/toggle-activation"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingAliasId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingAliasId, "emailForwardingAliasId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.emailForwardingAliasesToggleActivation
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsAliasesUpdateRecipientsRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	emailForwardingAliasId string
	emailForwardingAliasesRecipients *EmailForwardingAliasesRecipients
}

func (r ApiEmailForwardingsAliasesUpdateRecipientsRequest) EmailForwardingAliasesRecipients(emailForwardingAliasesRecipients EmailForwardingAliasesRecipients) ApiEmailForwardingsAliasesUpdateRecipientsRequest {
	r.emailForwardingAliasesRecipients = &emailForwardingAliasesRecipients
	return r
}

func (r ApiEmailForwardingsAliasesUpdateRecipientsRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsAliasesUpdateRecipientsExecute(r)
}

/*
EmailForwardingsAliasesUpdateRecipients Update alias recipients

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @param emailForwardingAliasId Email forwarding alias id
 @return ApiEmailForwardingsAliasesUpdateRecipientsRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsAliasesUpdateRecipients(ctx context.Context, domain string, emailForwardingId string, emailForwardingAliasId string) ApiEmailForwardingsAliasesUpdateRecipientsRequest {
	return ApiEmailForwardingsAliasesUpdateRecipientsRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
		emailForwardingAliasId: emailForwardingAliasId,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsAliasesUpdateRecipientsExecute(r ApiEmailForwardingsAliasesUpdateRecipientsRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPatch
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsAliasesUpdateRecipients")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/aliases/{emailForwardingAliasId}/recipients"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingAliasId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingAliasId, "emailForwardingAliasId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.emailForwardingAliasesRecipients
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsCatchAllActivateRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
}

func (r ApiEmailForwardingsCatchAllActivateRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsCatchAllActivateExecute(r)
}

/*
EmailForwardingsCatchAllActivate Activate email forwarding catch all

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @return ApiEmailForwardingsCatchAllActivateRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsCatchAllActivate(ctx context.Context, domain string) ApiEmailForwardingsCatchAllActivateRequest {
	return ApiEmailForwardingsCatchAllActivateRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsCatchAllActivateExecute(r ApiEmailForwardingsCatchAllActivateRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsCatchAllActivate")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/catch-all/activate"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 409 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsCatchAllDeactivateRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
}

func (r ApiEmailForwardingsCatchAllDeactivateRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsCatchAllDeactivateExecute(r)
}

/*
EmailForwardingsCatchAllDeactivate Deactivate email forwarding catch all

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @return ApiEmailForwardingsCatchAllDeactivateRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsCatchAllDeactivate(ctx context.Context, domain string) ApiEmailForwardingsCatchAllDeactivateRequest {
	return ApiEmailForwardingsCatchAllDeactivateRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsCatchAllDeactivateExecute(r ApiEmailForwardingsCatchAllDeactivateRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsCatchAllDeactivate")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/catch-all/deactivate"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 409 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsDeactivateRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
}

func (r ApiEmailForwardingsDeactivateRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsDeactivateExecute(r)
}

/*
EmailForwardingsDeactivate Deactivate email forwarding

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @return ApiEmailForwardingsDeactivateRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsDeactivate(ctx context.Context, domain string) ApiEmailForwardingsDeactivateRequest {
	return ApiEmailForwardingsDeactivateRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsDeactivateExecute(r ApiEmailForwardingsDeactivateRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsDeactivate")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/deactivate"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 409 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsRecipientsDestroyRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	emailForwardingRecipientId string
}

func (r ApiEmailForwardingsRecipientsDestroyRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsRecipientsDestroyExecute(r)
}

/*
EmailForwardingsRecipientsDestroy Delete a recipient

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @param emailForwardingRecipientId Email forwarding recipient id
 @return ApiEmailForwardingsRecipientsDestroyRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsRecipientsDestroy(ctx context.Context, domain string, emailForwardingId string, emailForwardingRecipientId string) ApiEmailForwardingsRecipientsDestroyRequest {
	return ApiEmailForwardingsRecipientsDestroyRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
		emailForwardingRecipientId: emailForwardingRecipientId,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsRecipientsDestroyExecute(r ApiEmailForwardingsRecipientsDestroyRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodDelete
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsRecipientsDestroy")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/recipients/{emailForwardingRecipientId}"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingRecipientId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingRecipientId, "emailForwardingRecipientId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 500 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsRecipientsIndexRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	perPage *int32
	page *int32
}

// Set how many items returned per page
func (r ApiEmailForwardingsRecipientsIndexRequest) PerPage(perPage int32) ApiEmailForwardingsRecipientsIndexRequest {
	r.perPage = &perPage
	return r
}

// Set the desired page number
func (r ApiEmailForwardingsRecipientsIndexRequest) Page(page int32) ApiEmailForwardingsRecipientsIndexRequest {
	r.page = &page
	return r
}

func (r ApiEmailForwardingsRecipientsIndexRequest) Execute() (*EmailForwardingRecipientsListData, *http.Response, error) {
	return r.ApiService.EmailForwardingsRecipientsIndexExecute(r)
}

/*
EmailForwardingsRecipientsIndex List recipients of an email forwarding

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @return ApiEmailForwardingsRecipientsIndexRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsRecipientsIndex(ctx context.Context, domain string, emailForwardingId string) ApiEmailForwardingsRecipientsIndexRequest {
	return ApiEmailForwardingsRecipientsIndexRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
	}
}

// Execute executes the request
//  @return EmailForwardingRecipientsListData
func (a *EmailForwardingApiService) EmailForwardingsRecipientsIndexExecute(r ApiEmailForwardingsRecipientsIndexRequest) (*EmailForwardingRecipientsListData, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *EmailForwardingRecipientsListData
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsRecipientsIndex")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/recipients"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.perPage != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "per_page", r.perPage, "")
	}
	if r.page != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "page", r.page, "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsRecipientsResendVerificationRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	emailForwardingRecipientId string
}

func (r ApiEmailForwardingsRecipientsResendVerificationRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsRecipientsResendVerificationExecute(r)
}

/*
EmailForwardingsRecipientsResendVerification Resend Verification

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @param emailForwardingRecipientId Email forwarding recipient id
 @return ApiEmailForwardingsRecipientsResendVerificationRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsRecipientsResendVerification(ctx context.Context, domain string, emailForwardingId string, emailForwardingRecipientId string) ApiEmailForwardingsRecipientsResendVerificationRequest {
	return ApiEmailForwardingsRecipientsResendVerificationRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
		emailForwardingRecipientId: emailForwardingRecipientId,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsRecipientsResendVerificationExecute(r ApiEmailForwardingsRecipientsResendVerificationRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsRecipientsResendVerification")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/recipients/{emailForwardingRecipientId}/resend-verification"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingRecipientId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingRecipientId, "emailForwardingRecipientId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 409 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsRecipientsSetDefaultRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	emailForwardingRecipientId string
}

func (r ApiEmailForwardingsRecipientsSetDefaultRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsRecipientsSetDefaultExecute(r)
}

/*
EmailForwardingsRecipientsSetDefault Set default recipient

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @param emailForwardingRecipientId Email forwarding recipient id
 @return ApiEmailForwardingsRecipientsSetDefaultRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsRecipientsSetDefault(ctx context.Context, domain string, emailForwardingId string, emailForwardingRecipientId string) ApiEmailForwardingsRecipientsSetDefaultRequest {
	return ApiEmailForwardingsRecipientsSetDefaultRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
		emailForwardingRecipientId: emailForwardingRecipientId,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsRecipientsSetDefaultExecute(r ApiEmailForwardingsRecipientsSetDefaultRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPatch
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsRecipientsSetDefault")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/recipients/{emailForwardingRecipientId}/set-default"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingRecipientId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingRecipientId, "emailForwardingRecipientId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 403 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
			return localVarReturnValue, localVarHTTPResponse, newErr
		}
		if localVarHTTPResponse.StatusCode == 409 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsRecipientsStoreRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	emailForwardingRecipientsStore *EmailForwardingRecipientsStore
}

func (r ApiEmailForwardingsRecipientsStoreRequest) EmailForwardingRecipientsStore(emailForwardingRecipientsStore EmailForwardingRecipientsStore) ApiEmailForwardingsRecipientsStoreRequest {
	r.emailForwardingRecipientsStore = &emailForwardingRecipientsStore
	return r
}

func (r ApiEmailForwardingsRecipientsStoreRequest) Execute() (*EmailForwardingsRecipientsStore201Response, *http.Response, error) {
	return r.ApiService.EmailForwardingsRecipientsStoreExecute(r)
}

/*
EmailForwardingsRecipientsStore Create new recipient

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @return ApiEmailForwardingsRecipientsStoreRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsRecipientsStore(ctx context.Context, domain string, emailForwardingId string) ApiEmailForwardingsRecipientsStoreRequest {
	return ApiEmailForwardingsRecipientsStoreRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
	}
}

// Execute executes the request
//  @return EmailForwardingsRecipientsStore201Response
func (a *EmailForwardingApiService) EmailForwardingsRecipientsStoreExecute(r ApiEmailForwardingsRecipientsStoreRequest) (*EmailForwardingsRecipientsStore201Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *EmailForwardingsRecipientsStore201Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsRecipientsStore")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/recipients"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.emailForwardingRecipientsStore
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 409 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsRecipientsVerifyRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
	emailForwardingId string
	emailForwardingRecipientId string
	emailForwardingRecipientsVerify *EmailForwardingRecipientsVerify
}

func (r ApiEmailForwardingsRecipientsVerifyRequest) EmailForwardingRecipientsVerify(emailForwardingRecipientsVerify EmailForwardingRecipientsVerify) ApiEmailForwardingsRecipientsVerifyRequest {
	r.emailForwardingRecipientsVerify = &emailForwardingRecipientsVerify
	return r
}

func (r ApiEmailForwardingsRecipientsVerifyRequest) Execute() (*MessageResponse, *http.Response, error) {
	return r.ApiService.EmailForwardingsRecipientsVerifyExecute(r)
}

/*
EmailForwardingsRecipientsVerify Verify recipient

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @param emailForwardingId Email forwarding id
 @param emailForwardingRecipientId Email forwarding recipient id
 @return ApiEmailForwardingsRecipientsVerifyRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsRecipientsVerify(ctx context.Context, domain string, emailForwardingId string, emailForwardingRecipientId string) ApiEmailForwardingsRecipientsVerifyRequest {
	return ApiEmailForwardingsRecipientsVerifyRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
		emailForwardingId: emailForwardingId,
		emailForwardingRecipientId: emailForwardingRecipientId,
	}
}

// Execute executes the request
//  @return MessageResponse
func (a *EmailForwardingApiService) EmailForwardingsRecipientsVerifyExecute(r ApiEmailForwardingsRecipientsVerifyRequest) (*MessageResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *MessageResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsRecipientsVerify")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/{emailForwardingId}/recipients/{emailForwardingRecipientId}/verify"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingId, "emailForwardingId")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"emailForwardingRecipientId"+"}", url.PathEscape(parameterValueToString(r.emailForwardingRecipientId, "emailForwardingRecipientId")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.emailForwardingRecipientsVerify
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 409 {
			var v MessageResponse
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
					newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiEmailForwardingsStatsRequest struct {
	ctx context.Context
	ApiService *EmailForwardingApiService
	domain string
}

func (r ApiEmailForwardingsStatsRequest) Execute() (*EmailForwardingStatsData, *http.Response, error) {
	return r.ApiService.EmailForwardingsStatsExecute(r)
}

/*
EmailForwardingsStats Show stats of domain's email forwarding

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param domain Domain name
 @return ApiEmailForwardingsStatsRequest
*/
func (a *EmailForwardingApiService) EmailForwardingsStats(ctx context.Context, domain string) ApiEmailForwardingsStatsRequest {
	return ApiEmailForwardingsStatsRequest{
		ApiService: a,
		ctx: ctx,
		domain: domain,
	}
}

// Execute executes the request
//  @return EmailForwardingStatsData
func (a *EmailForwardingApiService) EmailForwardingsStatsExecute(r ApiEmailForwardingsStatsRequest) (*EmailForwardingStatsData, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *EmailForwardingStatsData
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EmailForwardingApiService.EmailForwardingsStats")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/domains/{domain}/email-forwardings/stats"
	localVarPath = strings.Replace(localVarPath, "{"+"domain"+"}", url.PathEscape(parameterValueToString(r.domain, "domain")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["ApiKey"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["Authorization"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}