api_certificate_store.go

/*
Copyright 2022 Keyfactor
Licensed under the Apache License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License.  You may obtain a
copy of the License at http://www.apache.org/licenses/LICENSE-2.0.  Unless
required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
OR CONDITIONS OF ANY KIND, either express or implied. See the License for
thespecific language governing permissions and limitations under the
License.
Keyfactor-v1

This reference serves to document REST-based methods to manage and integrate with Keyfactor. In addition, an embedded interface allows for the execution of calls against the current Keyfactor API instance.

API version: v1
*/

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

package keyfactor

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


// CertificateStoreApiService CertificateStoreApi service
type CertificateStoreApiService service

type ApiCertificateStoreAddCertificateRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	addRequest *KeyfactorApiModelsCertificateStoresAddCertificateRequest
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreAddCertificateRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreAddCertificateRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Configuration details of the management job
func (r ApiCertificateStoreAddCertificateRequest) AddRequest(addRequest KeyfactorApiModelsCertificateStoresAddCertificateRequest) ApiCertificateStoreAddCertificateRequest {
	r.addRequest = &addRequest
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreAddCertificateRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreAddCertificateRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreAddCertificateRequest) Execute() ([]string, *http.Response, error) {
	return r.ApiService.CertificateStoreAddCertificateExecute(r)
}

/*
CertificateStoreAddCertificate Configures a management job to add a certificate to one or more stores with the provided schedule

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreAddCertificateRequest
*/
func (a *CertificateStoreApiService) CertificateStoreAddCertificate(ctx context.Context) ApiCertificateStoreAddCertificateRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreAddCertificateRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
//  @return []string
func (a *CertificateStoreApiService) CertificateStoreAddCertificateExecute(r ApiCertificateStoreAddCertificateRequest) ([]string, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  []string
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/Certificates/Add"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return localVarReturnValue, nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.addRequest == nil {
        return localVarReturnValue, nil, reportError("addRequest is required and must be specified")
    }

	// 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
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.addRequest
	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 := ioutil.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = ioutil.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 ApiCertificateStoreApprovePendingRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	keystores *[]KeyfactorApiModelsCertificateStoresCertificateStoreApproveRequest
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreApprovePendingRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreApprovePendingRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Certificate stores to be approved
func (r ApiCertificateStoreApprovePendingRequest) Keystores(keystores []KeyfactorApiModelsCertificateStoresCertificateStoreApproveRequest) ApiCertificateStoreApprovePendingRequest {
	r.keystores = &keystores
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreApprovePendingRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreApprovePendingRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreApprovePendingRequest) Execute() (*http.Response, error) {
	return r.ApiService.CertificateStoreApprovePendingExecute(r)
}

/*
CertificateStoreApprovePending Approves the provided certificate stores to make them available for management

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreApprovePendingRequest
*/
func (a *CertificateStoreApiService) CertificateStoreApprovePending(ctx context.Context) ApiCertificateStoreApprovePendingRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreApprovePendingRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
func (a *CertificateStoreApiService) CertificateStoreApprovePendingExecute(r ApiCertificateStoreApprovePendingRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/Approve"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.keystores == nil {
        return nil, reportError("keystores is required and must be specified")
    }

	// 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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.keystores
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

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

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

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

	return localVarHTTPResponse, nil
}

type ApiCertificateStoreConfigureDiscoveryJobRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	discoveryJobRequest *ModelsDiscoveryJobRequest
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreConfigureDiscoveryJobRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreConfigureDiscoveryJobRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Configuration properties of the discovery job
func (r ApiCertificateStoreConfigureDiscoveryJobRequest) DiscoveryJobRequest(discoveryJobRequest ModelsDiscoveryJobRequest) ApiCertificateStoreConfigureDiscoveryJobRequest {
	r.discoveryJobRequest = &discoveryJobRequest
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreConfigureDiscoveryJobRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreConfigureDiscoveryJobRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreConfigureDiscoveryJobRequest) Execute() (*http.Response, error) {
	return r.ApiService.CertificateStoreConfigureDiscoveryJobExecute(r)
}

/*
CertificateStoreConfigureDiscoveryJob Configures a discovery job to locate currently unmanaged certificate stores

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreConfigureDiscoveryJobRequest
*/
func (a *CertificateStoreApiService) CertificateStoreConfigureDiscoveryJob(ctx context.Context) ApiCertificateStoreConfigureDiscoveryJobRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreConfigureDiscoveryJobRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
func (a *CertificateStoreApiService) CertificateStoreConfigureDiscoveryJobExecute(r ApiCertificateStoreConfigureDiscoveryJobRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPut
		localVarPostBody     interface{}
		formFiles            []formFile
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/DiscoveryJob"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.discoveryJobRequest == nil {
        return nil, reportError("discoveryJobRequest is required and must be specified")
    }

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json", "text/json", "application/xml", "text/xml", "application/x-www-form-urlencoded"}

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

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

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.discoveryJobRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

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

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

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

	return localVarHTTPResponse, nil
}

type ApiCertificateStoreCreateCertificateStoreServerRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	request *ModelsCertificateStoreCreateServerRequest
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreCreateCertificateStoreServerRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreCreateCertificateStoreServerRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Certificate store server to be created with the provided properties
func (r ApiCertificateStoreCreateCertificateStoreServerRequest) Request(request ModelsCertificateStoreCreateServerRequest) ApiCertificateStoreCreateCertificateStoreServerRequest {
	r.request = &request
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreCreateCertificateStoreServerRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreCreateCertificateStoreServerRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreCreateCertificateStoreServerRequest) Execute() (*ModelsCertificateStoreServerResponse, *http.Response, error) {
	return r.ApiService.CertificateStoreCreateCertificateStoreServerExecute(r)
}

/*
CertificateStoreCreateCertificateStoreServer Creates a new certificate store server with the provided properties

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreCreateCertificateStoreServerRequest

Deprecated
*/
func (a *CertificateStoreApiService) CertificateStoreCreateCertificateStoreServer(ctx context.Context) ApiCertificateStoreCreateCertificateStoreServerRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreCreateCertificateStoreServerRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
//  @return ModelsCertificateStoreServerResponse
// Deprecated
func (a *CertificateStoreApiService) CertificateStoreCreateCertificateStoreServerExecute(r ApiCertificateStoreCreateCertificateStoreServerRequest) (*ModelsCertificateStoreServerResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *ModelsCertificateStoreServerResponse
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/Server"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return localVarReturnValue, nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.request == nil {
        return localVarReturnValue, nil, reportError("request is required and must be specified")
    }

	// 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
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.request
	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 := ioutil.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = ioutil.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 ApiCertificateStoreDeleteCertificateStoreRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	id string
	xKeyfactorRequestedWith *string
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreDeleteCertificateStoreRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreDeleteCertificateStoreRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreDeleteCertificateStoreRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreDeleteCertificateStoreRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreDeleteCertificateStoreRequest) Execute() (*http.Response, error) {
	return r.ApiService.CertificateStoreDeleteCertificateStoreExecute(r)
}

/*
CertificateStoreDeleteCertificateStore Deletes a persisted certificate store by its Keyfactor identifier

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param id Keyfactor certificate store identifier (GUID)
 @return ApiCertificateStoreDeleteCertificateStoreRequest
*/
func (a *CertificateStoreApiService) CertificateStoreDeleteCertificateStore(ctx context.Context, id string) ApiCertificateStoreDeleteCertificateStoreRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreDeleteCertificateStoreRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
		id: id,
	}
}

// Execute executes the request
func (a *CertificateStoreApiService) CertificateStoreDeleteCertificateStoreExecute(r ApiCertificateStoreDeleteCertificateStoreRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodDelete
		localVarPostBody     interface{}
		formFiles            []formFile
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/{id}"
	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }

	// 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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

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

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

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

	return localVarHTTPResponse, nil
}

type ApiCertificateStoreDeleteCertificateStoresRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	ids *[]string
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreDeleteCertificateStoresRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreDeleteCertificateStoresRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Array of Keyfactor identifiers (GUID) for the certificate stores to be deleted
func (r ApiCertificateStoreDeleteCertificateStoresRequest) Ids(ids []string) ApiCertificateStoreDeleteCertificateStoresRequest {
	r.ids = &ids
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreDeleteCertificateStoresRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreDeleteCertificateStoresRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreDeleteCertificateStoresRequest) Execute() (*http.Response, error) {
	return r.ApiService.CertificateStoreDeleteCertificateStoresExecute(r)
}

/*
CertificateStoreDeleteCertificateStores Deletes multiple persisted certificate store entities by their identifiers

This will ignore individual delete failures, and continue processing the array.

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreDeleteCertificateStoresRequest
*/
func (a *CertificateStoreApiService) CertificateStoreDeleteCertificateStores(ctx context.Context) ApiCertificateStoreDeleteCertificateStoresRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreDeleteCertificateStoresRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
func (a *CertificateStoreApiService) CertificateStoreDeleteCertificateStoresExecute(r ApiCertificateStoreDeleteCertificateStoresRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodDelete
		localVarPostBody     interface{}
		formFiles            []formFile
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.ids == nil {
        return nil, reportError("ids is required and must be specified")
    }

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json", "text/json", "application/xml", "text/xml", "application/x-www-form-urlencoded"}

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

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

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.ids
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

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

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

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

	return localVarHTTPResponse, nil
}

type ApiCertificateStoreGetCertificateStoreInventoryRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	id string
	xKeyfactorRequestedWith *string
	xKeyfactorApiVersion *string
	queryPageReturned *int32
	queryReturnLimit *int32
	querySortField *string
	querySortAscending *int32
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreGetCertificateStoreInventoryRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreGetCertificateStoreInventoryRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreGetCertificateStoreInventoryRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreGetCertificateStoreInventoryRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

// The current page within the result set to be returned
func (r ApiCertificateStoreGetCertificateStoreInventoryRequest) QueryPageReturned(queryPageReturned int32) ApiCertificateStoreGetCertificateStoreInventoryRequest {
	r.queryPageReturned = &queryPageReturned
	return r
}

// Maximum number of records to be returned in a single call
func (r ApiCertificateStoreGetCertificateStoreInventoryRequest) QueryReturnLimit(queryReturnLimit int32) ApiCertificateStoreGetCertificateStoreInventoryRequest {
	r.queryReturnLimit = &queryReturnLimit
	return r
}

// Field by which the results should be sorted (OperationStart, OperationEnd, UserName)
func (r ApiCertificateStoreGetCertificateStoreInventoryRequest) QuerySortField(querySortField string) ApiCertificateStoreGetCertificateStoreInventoryRequest {
	r.querySortField = &querySortField
	return r
}

// Field sort direction [0=ascending, 1=descending]
func (r ApiCertificateStoreGetCertificateStoreInventoryRequest) QuerySortAscending(querySortAscending int32) ApiCertificateStoreGetCertificateStoreInventoryRequest {
	r.querySortAscending = &querySortAscending
	return r
}

func (r ApiCertificateStoreGetCertificateStoreInventoryRequest) Execute() ([]ModelsCertificateStoreInventory, *http.Response, error) {
	return r.ApiService.CertificateStoreGetCertificateStoreInventoryExecute(r)
}

/*
CertificateStoreGetCertificateStoreInventory Returns a single certificate store's inventory associated with the provided id

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param id Keyfactor identifier (GUID) of the certificate store
 @return ApiCertificateStoreGetCertificateStoreInventoryRequest
*/
func (a *CertificateStoreApiService) CertificateStoreGetCertificateStoreInventory(ctx context.Context, id string) ApiCertificateStoreGetCertificateStoreInventoryRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreGetCertificateStoreInventoryRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
		id: id,
	}
}

// Execute executes the request
//  @return []ModelsCertificateStoreInventory
func (a *CertificateStoreApiService) CertificateStoreGetCertificateStoreInventoryExecute(r ApiCertificateStoreGetCertificateStoreInventoryRequest) ([]ModelsCertificateStoreInventory, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  []ModelsCertificateStoreInventory
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/{id}/Inventory"
	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return localVarReturnValue, nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }

	if r.queryPageReturned != nil {
		parameterAddToQuery(localVarQueryParams, "query.pageReturned", r.queryPageReturned, "")
	}
	if r.queryReturnLimit != nil {
		parameterAddToQuery(localVarQueryParams, "query.returnLimit", r.queryReturnLimit, "")
	}
	if r.querySortField != nil {
		parameterAddToQuery(localVarQueryParams, "query.sortField", r.querySortField, "")
	}
	if r.querySortAscending != nil {
		parameterAddToQuery(localVarQueryParams, "query.sortAscending", r.querySortAscending, "")
	}
	// 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", "text/json", "application/xml", "text/xml"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	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 := ioutil.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = ioutil.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 ApiCertificateStoreRemoveCertificateRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	removalRequest *KeyfactorApiModelsCertificateStoresRemoveCertificateRequest
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreRemoveCertificateRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreRemoveCertificateRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Configuration details of the management job
func (r ApiCertificateStoreRemoveCertificateRequest) RemovalRequest(removalRequest KeyfactorApiModelsCertificateStoresRemoveCertificateRequest) ApiCertificateStoreRemoveCertificateRequest {
	r.removalRequest = &removalRequest
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreRemoveCertificateRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreRemoveCertificateRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreRemoveCertificateRequest) Execute() ([]string, *http.Response, error) {
	return r.ApiService.CertificateStoreRemoveCertificateExecute(r)
}

/*
CertificateStoreRemoveCertificate Configures a management job to remove a certificate from one or more stores with the provided schedule

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreRemoveCertificateRequest
*/
func (a *CertificateStoreApiService) CertificateStoreRemoveCertificate(ctx context.Context) ApiCertificateStoreRemoveCertificateRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreRemoveCertificateRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
//  @return []string
func (a *CertificateStoreApiService) CertificateStoreRemoveCertificateExecute(r ApiCertificateStoreRemoveCertificateRequest) ([]string, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  []string
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/Certificates/Remove"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return localVarReturnValue, nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.removalRequest == nil {
        return localVarReturnValue, nil, reportError("removalRequest is required and must be specified")
    }

	// 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
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.removalRequest
	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 := ioutil.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = ioutil.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 ApiCertificateStoreScheduleRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	futureSchedule *ModelsCertStoresSchedule
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreScheduleRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreScheduleRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Certificate store identifiers and the desired schedule
func (r ApiCertificateStoreScheduleRequest) FutureSchedule(futureSchedule ModelsCertStoresSchedule) ApiCertificateStoreScheduleRequest {
	r.futureSchedule = &futureSchedule
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreScheduleRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreScheduleRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreScheduleRequest) Execute() (*http.Response, error) {
	return r.ApiService.CertificateStoreScheduleExecute(r)
}

/*
CertificateStoreSchedule Creates an inventory schedule for the provided certificate stores

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreScheduleRequest
*/
func (a *CertificateStoreApiService) CertificateStoreSchedule(ctx context.Context) ApiCertificateStoreScheduleRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreScheduleRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
func (a *CertificateStoreApiService) CertificateStoreScheduleExecute(r ApiCertificateStoreScheduleRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/Schedule"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.futureSchedule == nil {
        return nil, reportError("futureSchedule is required and must be specified")
    }

	// 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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.futureSchedule
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

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

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

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

	return localVarHTTPResponse, nil
}

type ApiCertificateStoreScheduleForReenrollmentRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	reenroll *KeyfactorApiModelsCertificateStoresReenrollmentRequest
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreScheduleForReenrollmentRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreScheduleForReenrollmentRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// An object that contains a Keystore Id, a Agent Guid, a string SubjectName and string Alias
func (r ApiCertificateStoreScheduleForReenrollmentRequest) Reenroll(reenroll KeyfactorApiModelsCertificateStoresReenrollmentRequest) ApiCertificateStoreScheduleForReenrollmentRequest {
	r.reenroll = &reenroll
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreScheduleForReenrollmentRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreScheduleForReenrollmentRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreScheduleForReenrollmentRequest) Execute() (*http.Response, error) {
	return r.ApiService.CertificateStoreScheduleForReenrollmentExecute(r)
}

/*
CertificateStoreScheduleForReenrollment Schedules a certificate store for reenrollment

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreScheduleForReenrollmentRequest
*/
func (a *CertificateStoreApiService) CertificateStoreScheduleForReenrollment(ctx context.Context) ApiCertificateStoreScheduleForReenrollmentRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreScheduleForReenrollmentRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
func (a *CertificateStoreApiService) CertificateStoreScheduleForReenrollmentExecute(r ApiCertificateStoreScheduleForReenrollmentRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/Reenrollment"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.reenroll == nil {
        return nil, reportError("reenroll is required and must be specified")
    }

	// 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{}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.reenroll
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

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

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

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

	return localVarHTTPResponse, nil
}

type ApiCertificateStoreSetPasswordRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	passwordRequest *ModelsCertStoreNewPasswordRequest
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreSetPasswordRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreSetPasswordRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Identifier of the certificate store and the password to be applied to it
func (r ApiCertificateStoreSetPasswordRequest) PasswordRequest(passwordRequest ModelsCertStoreNewPasswordRequest) ApiCertificateStoreSetPasswordRequest {
	r.passwordRequest = &passwordRequest
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreSetPasswordRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreSetPasswordRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreSetPasswordRequest) Execute() (*http.Response, error) {
	return r.ApiService.CertificateStoreSetPasswordExecute(r)
}

/*
CertificateStoreSetPassword Sets a password for the requested certificate store

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreSetPasswordRequest
*/
func (a *CertificateStoreApiService) CertificateStoreSetPassword(ctx context.Context) ApiCertificateStoreSetPasswordRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreSetPasswordRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
func (a *CertificateStoreApiService) CertificateStoreSetPasswordExecute(r ApiCertificateStoreSetPasswordRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPut
		localVarPostBody     interface{}
		formFiles            []formFile
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/Password"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.passwordRequest == nil {
        return nil, reportError("passwordRequest is required and must be specified")
    }

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json", "text/json", "application/xml", "text/xml", "application/x-www-form-urlencoded"}

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

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

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.passwordRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

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

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

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

	return localVarHTTPResponse, nil
}

type ApiCertificateStoreUpdateCertificateStoreServerRequest struct {
	ctx context.Context
	ApiService *CertificateStoreApiService
	xKeyfactorRequestedWith *string
	request *ModelsCertificateStoreUpdateServerRequest
	xKeyfactorApiVersion *string
}

// Type of the request [XMLHttpRequest, APIClient]
func (r ApiCertificateStoreUpdateCertificateStoreServerRequest) XKeyfactorRequestedWith(xKeyfactorRequestedWith string) ApiCertificateStoreUpdateCertificateStoreServerRequest {
	r.xKeyfactorRequestedWith = &xKeyfactorRequestedWith
	return r
}

// Server to be updated with the provided properties
func (r ApiCertificateStoreUpdateCertificateStoreServerRequest) Request(request ModelsCertificateStoreUpdateServerRequest) ApiCertificateStoreUpdateCertificateStoreServerRequest {
	r.request = &request
	return r
}

// Desired version of the api, if not provided defaults to v1
func (r ApiCertificateStoreUpdateCertificateStoreServerRequest) XKeyfactorApiVersion(xKeyfactorApiVersion string) ApiCertificateStoreUpdateCertificateStoreServerRequest {
	r.xKeyfactorApiVersion = &xKeyfactorApiVersion
	return r
}

func (r ApiCertificateStoreUpdateCertificateStoreServerRequest) Execute() (*ModelsCertificateStoreServerResponse, *http.Response, error) {
	return r.ApiService.CertificateStoreUpdateCertificateStoreServerExecute(r)
}

/*
CertificateStoreUpdateCertificateStoreServer Updates a given certificate store server with the properties of the provided instance

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiCertificateStoreUpdateCertificateStoreServerRequest

Deprecated
*/
func (a *CertificateStoreApiService) CertificateStoreUpdateCertificateStoreServer(ctx context.Context) ApiCertificateStoreUpdateCertificateStoreServerRequest {
    requestedWith := "APIClient"
    version := "1"
	return ApiCertificateStoreUpdateCertificateStoreServerRequest{
		ApiService: a,
		ctx: ctx,
		xKeyfactorRequestedWith: &requestedWith,
		xKeyfactorApiVersion: &version,
	}
}

// Execute executes the request
//  @return ModelsCertificateStoreServerResponse
// Deprecated
func (a *CertificateStoreApiService) CertificateStoreUpdateCertificateStoreServerExecute(r ApiCertificateStoreUpdateCertificateStoreServerRequest) (*ModelsCertificateStoreServerResponse, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPut
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *ModelsCertificateStoreServerResponse
	)

	localBasePath := "/KeyfactorAPI"

	localVarPath := localBasePath + "/CertificateStores/Server"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
    if r.xKeyfactorRequestedWith == nil {
        return localVarReturnValue, nil, reportError("xKeyfactorRequestedWith is required and must be specified")
    }
    if r.request == nil {
        return localVarReturnValue, nil, reportError("request is required and must be specified")
    }

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json", "text/json", "application/xml", "text/xml", "application/x-www-form-urlencoded"}

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

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

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.xKeyfactorApiVersion != nil {
		parameterAddToQuery(localVarHeaderParams, "x-keyfactor-api-version", r.xKeyfactorApiVersion, "")
	}
	parameterAddToQuery(localVarHeaderParams, "x-keyfactor-requested-with", r.xKeyfactorRequestedWith, "")
	// body params
	localVarPostBody = r.request
	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 := ioutil.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = ioutil.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
}