From 225e1d7b965fddd605481177f913ba93962ef997 Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Thu, 19 Dec 2024 14:18:08 +0000 Subject: [PATCH 1/2] Generate iaas --- services/iaas/api_default.go | 553 ++++++++++++++++++ services/iaas/api_default_test.go | 162 +++++ services/iaas/model_quota.go | 138 +++++ services/iaas/model_quota_list.go | 418 +++++++++++++ .../iaas/model_quota_list_backup_gigabytes.go | 138 +++++ services/iaas/model_quota_list_backups.go | 138 +++++ services/iaas/model_quota_list_gigabytes.go | 138 +++++ services/iaas/model_quota_list_networks.go | 138 +++++ services/iaas/model_quota_list_nics.go | 138 +++++ services/iaas/model_quota_list_public_ips.go | 138 +++++ services/iaas/model_quota_list_ram.go | 138 +++++ services/iaas/model_quota_list_response.go | 110 ++++ .../model_quota_list_security_group_rules.go | 138 +++++ .../iaas/model_quota_list_security_groups.go | 138 +++++ services/iaas/model_quota_list_snapshots.go | 138 +++++ services/iaas/model_quota_list_vcpu.go | 138 +++++ services/iaas/model_quota_list_volumes.go | 138 +++++ 17 files changed, 3037 insertions(+) create mode 100644 services/iaas/model_quota.go create mode 100644 services/iaas/model_quota_list.go create mode 100644 services/iaas/model_quota_list_backup_gigabytes.go create mode 100644 services/iaas/model_quota_list_backups.go create mode 100644 services/iaas/model_quota_list_gigabytes.go create mode 100644 services/iaas/model_quota_list_networks.go create mode 100644 services/iaas/model_quota_list_nics.go create mode 100644 services/iaas/model_quota_list_public_ips.go create mode 100644 services/iaas/model_quota_list_ram.go create mode 100644 services/iaas/model_quota_list_response.go create mode 100644 services/iaas/model_quota_list_security_group_rules.go create mode 100644 services/iaas/model_quota_list_security_groups.go create mode 100644 services/iaas/model_quota_list_snapshots.go create mode 100644 services/iaas/model_quota_list_vcpu.go create mode 100644 services/iaas/model_quota_list_volumes.go diff --git a/services/iaas/api_default.go b/services/iaas/api_default.go index 1ed6aad5..49b527a7 100644 --- a/services/iaas/api_default.go +++ b/services/iaas/api_default.go @@ -15079,6 +15079,183 @@ func (a *APIClient) ListPublicIPsExecute(ctx context.Context, projectId string) return r.Execute() } +type ApiListQuotasRequest struct { + ctx context.Context + apiService *DefaultApiService + projectId string +} + +func (r ApiListQuotasRequest) Execute() (*QuotaListResponse, error) { + var ( + localVarHTTPMethod = http.MethodGet + localVarPostBody interface{} + formFiles []formFile + localVarReturnValue *QuotaListResponse + ) + a := r.apiService + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.ListQuotas") + if err != nil { + return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()} + } + + localVarPath := localBasePath + "/v1beta1/projects/{projectId}/quotas" + localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1) + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + if strlen(r.projectId) < 36 { + return localVarReturnValue, fmt.Errorf("projectId must have at least 36 elements") + } + if strlen(r.projectId) > 36 { + return localVarReturnValue, fmt.Errorf("projectId must have less than 36 elements") + } + + // 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 + } + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return localVarReturnValue, err + } + + contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request) + if ok { + *contextHTTPRequest = req + } + + localVarHTTPResponse, err := a.client.callAPI(req) + contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response) + if ok { + *contextHTTPResponse = localVarHTTPResponse + } + if err != nil || localVarHTTPResponse == nil { + return localVarReturnValue, err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return localVarReturnValue, err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: localVarHTTPResponse.Status, + } + if localVarHTTPResponse.StatusCode == 400 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 401 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 403 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 404 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 500 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + } + return localVarReturnValue, newErr + } + + err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: err.Error(), + } + return localVarReturnValue, newErr + } + + return localVarReturnValue, nil +} + +/* +ListQuotas: List project quotas. + +List quota limits and usage for project resources. + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @param projectId The identifier (ID) of a STACKIT Project. + @return ApiListQuotasRequest +*/ +func (a *APIClient) ListQuotas(ctx context.Context, projectId string) ApiListQuotasRequest { + return ApiListQuotasRequest{ + apiService: a.defaultApi, + ctx: ctx, + projectId: projectId, + } +} + +func (a *APIClient) ListQuotasExecute(ctx context.Context, projectId string) (*QuotaListResponse, error) { + r := ApiListQuotasRequest{ + apiService: a.defaultApi, + ctx: ctx, + projectId: projectId, + } + return r.Execute() +} + type ApiListSecurityGroupRulesRequest struct { ctx context.Context apiService *DefaultApiService @@ -20520,6 +20697,382 @@ func (a *APIClient) UpdateImageExecute(ctx context.Context, projectId string, im return r.Execute() } +type ApiUpdateImageScopeLocalRequest struct { + ctx context.Context + apiService *DefaultApiService + projectId string + imageId string +} + +func (r ApiUpdateImageScopeLocalRequest) Execute() (*Image, error) { + var ( + localVarHTTPMethod = http.MethodDelete + localVarPostBody interface{} + formFiles []formFile + localVarReturnValue *Image + ) + a := r.apiService + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.UpdateImageScopeLocal") + if err != nil { + return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()} + } + + localVarPath := localBasePath + "/v1beta1/projects/{projectId}/images/{imageId}/publish" + localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1) + localVarPath = strings.Replace(localVarPath, "{"+"imageId"+"}", url.PathEscape(ParameterValueToString(r.imageId, "imageId")), -1) + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + if strlen(r.projectId) < 36 { + return localVarReturnValue, fmt.Errorf("projectId must have at least 36 elements") + } + if strlen(r.projectId) > 36 { + return localVarReturnValue, fmt.Errorf("projectId must have less than 36 elements") + } + if strlen(r.imageId) < 36 { + return localVarReturnValue, fmt.Errorf("imageId must have at least 36 elements") + } + if strlen(r.imageId) > 36 { + return localVarReturnValue, fmt.Errorf("imageId must have less than 36 elements") + } + + // 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 + } + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return localVarReturnValue, err + } + + contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request) + if ok { + *contextHTTPRequest = req + } + + localVarHTTPResponse, err := a.client.callAPI(req) + contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response) + if ok { + *contextHTTPResponse = localVarHTTPResponse + } + if err != nil || localVarHTTPResponse == nil { + return localVarReturnValue, err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return localVarReturnValue, err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: localVarHTTPResponse.Status, + } + if localVarHTTPResponse.StatusCode == 400 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 401 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 403 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 404 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 500 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + } + return localVarReturnValue, newErr + } + + err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: err.Error(), + } + return localVarReturnValue, newErr + } + + return localVarReturnValue, nil +} + +/* +UpdateImageScopeLocal: Update Image Scope to Local. + +Update the scope property of an existing Image inside a project to local. + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @param projectId The identifier (ID) of a STACKIT Project. + @param imageId The identifier (ID) of a STACKIT Image. + @return ApiUpdateImageScopeLocalRequest +*/ +func (a *APIClient) UpdateImageScopeLocal(ctx context.Context, projectId string, imageId string) ApiUpdateImageScopeLocalRequest { + return ApiUpdateImageScopeLocalRequest{ + apiService: a.defaultApi, + ctx: ctx, + projectId: projectId, + imageId: imageId, + } +} + +func (a *APIClient) UpdateImageScopeLocalExecute(ctx context.Context, projectId string, imageId string) (*Image, error) { + r := ApiUpdateImageScopeLocalRequest{ + apiService: a.defaultApi, + ctx: ctx, + projectId: projectId, + imageId: imageId, + } + return r.Execute() +} + +type ApiUpdateImageScopePublicRequest struct { + ctx context.Context + apiService *DefaultApiService + projectId string + imageId string +} + +func (r ApiUpdateImageScopePublicRequest) Execute() (*Image, error) { + var ( + localVarHTTPMethod = http.MethodPut + localVarPostBody interface{} + formFiles []formFile + localVarReturnValue *Image + ) + a := r.apiService + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.UpdateImageScopePublic") + if err != nil { + return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()} + } + + localVarPath := localBasePath + "/v1beta1/projects/{projectId}/images/{imageId}/publish" + localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1) + localVarPath = strings.Replace(localVarPath, "{"+"imageId"+"}", url.PathEscape(ParameterValueToString(r.imageId, "imageId")), -1) + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + if strlen(r.projectId) < 36 { + return localVarReturnValue, fmt.Errorf("projectId must have at least 36 elements") + } + if strlen(r.projectId) > 36 { + return localVarReturnValue, fmt.Errorf("projectId must have less than 36 elements") + } + if strlen(r.imageId) < 36 { + return localVarReturnValue, fmt.Errorf("imageId must have at least 36 elements") + } + if strlen(r.imageId) > 36 { + return localVarReturnValue, fmt.Errorf("imageId must have less than 36 elements") + } + + // 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 + } + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return localVarReturnValue, err + } + + contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request) + if ok { + *contextHTTPRequest = req + } + + localVarHTTPResponse, err := a.client.callAPI(req) + contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response) + if ok { + *contextHTTPResponse = localVarHTTPResponse + } + if err != nil || localVarHTTPResponse == nil { + return localVarReturnValue, err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return localVarReturnValue, err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: localVarHTTPResponse.Status, + } + if localVarHTTPResponse.StatusCode == 400 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 401 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 403 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 404 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + return localVarReturnValue, newErr + } + if localVarHTTPResponse.StatusCode == 500 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.ErrorMessage = err.Error() + return localVarReturnValue, newErr + } + newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.Model = v + } + return localVarReturnValue, newErr + } + + err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr := &oapierror.GenericOpenAPIError{ + StatusCode: localVarHTTPResponse.StatusCode, + Body: localVarBody, + ErrorMessage: err.Error(), + } + return localVarReturnValue, newErr + } + + return localVarReturnValue, nil +} + +/* +UpdateImageScopePublic: Update Image Scope to Public. + +Update the scope property of an existing Image inside a project to public. + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @param projectId The identifier (ID) of a STACKIT Project. + @param imageId The identifier (ID) of a STACKIT Image. + @return ApiUpdateImageScopePublicRequest +*/ +func (a *APIClient) UpdateImageScopePublic(ctx context.Context, projectId string, imageId string) ApiUpdateImageScopePublicRequest { + return ApiUpdateImageScopePublicRequest{ + apiService: a.defaultApi, + ctx: ctx, + projectId: projectId, + imageId: imageId, + } +} + +func (a *APIClient) UpdateImageScopePublicExecute(ctx context.Context, projectId string, imageId string) (*Image, error) { + r := ApiUpdateImageScopePublicRequest{ + apiService: a.defaultApi, + ctx: ctx, + projectId: projectId, + imageId: imageId, + } + return r.Execute() +} + type ApiUpdateImageShareRequest struct { ctx context.Context apiService *DefaultApiService diff --git a/services/iaas/api_default_test.go b/services/iaas/api_default_test.go index 8327dc81..bc2e57b2 100644 --- a/services/iaas/api_default_test.go +++ b/services/iaas/api_default_test.go @@ -4222,6 +4222,58 @@ func Test_iaas_DefaultApiService(t *testing.T) { } }) + t.Run("Test DefaultApiService ListQuotas", func(t *testing.T) { + path := "/v1beta1/projects/{projectId}/quotas" + projectIdValue := "projectId" + path = strings.Replace(path, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1) + + testDefaultApiServeMux := http.NewServeMux() + testDefaultApiServeMux.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) { + data := QuotaListResponse{} + w.Header().Add("Content-Type", "application/json") + json.NewEncoder(w).Encode(data) + }) + testServer := httptest.NewServer(testDefaultApiServeMux) + defer testServer.Close() + + configuration := &config.Configuration{ + DefaultHeader: make(map[string]string), + UserAgent: "OpenAPI-Generator/1.0.0/go", + Debug: false, + Region: "test_region", + Servers: config.ServerConfigurations{ + { + URL: testServer.URL, + Description: "Localhost for iaas_DefaultApi", + Variables: map[string]config.ServerVariable{ + "region": { + DefaultValue: "test_region.", + EnumValues: []string{ + "test_region.", + }, + }, + }, + }, + }, + OperationServers: map[string]config.ServerConfigurations{}, + } + apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication()) + if err != nil { + t.Fatalf("creating API client: %v", err) + } + + projectId := "projectId" + + resp, reqErr := apiClient.ListQuotas(context.Background(), projectId).Execute() + + if reqErr != nil { + t.Fatalf("error in call: %v", reqErr) + } + if resp == nil { + t.Fatalf("response not present") + } + }) + t.Run("Test DefaultApiService ListSecurityGroupRules", func(t *testing.T) { path := "/v1beta1/projects/{projectId}/security-groups/{securityGroupId}/rules" projectIdValue := "projectId" @@ -5692,6 +5744,116 @@ func Test_iaas_DefaultApiService(t *testing.T) { } }) + t.Run("Test DefaultApiService UpdateImageScopeLocal", func(t *testing.T) { + path := "/v1beta1/projects/{projectId}/images/{imageId}/publish" + projectIdValue := "projectId" + path = strings.Replace(path, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1) + imageIdValue := "imageId" + path = strings.Replace(path, "{"+"imageId"+"}", url.PathEscape(ParameterValueToString(imageIdValue, "imageId")), -1) + + testDefaultApiServeMux := http.NewServeMux() + testDefaultApiServeMux.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) { + data := Image{} + w.Header().Add("Content-Type", "application/json") + json.NewEncoder(w).Encode(data) + }) + testServer := httptest.NewServer(testDefaultApiServeMux) + defer testServer.Close() + + configuration := &config.Configuration{ + DefaultHeader: make(map[string]string), + UserAgent: "OpenAPI-Generator/1.0.0/go", + Debug: false, + Region: "test_region", + Servers: config.ServerConfigurations{ + { + URL: testServer.URL, + Description: "Localhost for iaas_DefaultApi", + Variables: map[string]config.ServerVariable{ + "region": { + DefaultValue: "test_region.", + EnumValues: []string{ + "test_region.", + }, + }, + }, + }, + }, + OperationServers: map[string]config.ServerConfigurations{}, + } + apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication()) + if err != nil { + t.Fatalf("creating API client: %v", err) + } + + projectId := "projectId" + imageId := "imageId" + + resp, reqErr := apiClient.UpdateImageScopeLocal(context.Background(), projectId, imageId).Execute() + + if reqErr != nil { + t.Fatalf("error in call: %v", reqErr) + } + if resp == nil { + t.Fatalf("response not present") + } + }) + + t.Run("Test DefaultApiService UpdateImageScopePublic", func(t *testing.T) { + path := "/v1beta1/projects/{projectId}/images/{imageId}/publish" + projectIdValue := "projectId" + path = strings.Replace(path, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1) + imageIdValue := "imageId" + path = strings.Replace(path, "{"+"imageId"+"}", url.PathEscape(ParameterValueToString(imageIdValue, "imageId")), -1) + + testDefaultApiServeMux := http.NewServeMux() + testDefaultApiServeMux.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) { + data := Image{} + w.Header().Add("Content-Type", "application/json") + json.NewEncoder(w).Encode(data) + }) + testServer := httptest.NewServer(testDefaultApiServeMux) + defer testServer.Close() + + configuration := &config.Configuration{ + DefaultHeader: make(map[string]string), + UserAgent: "OpenAPI-Generator/1.0.0/go", + Debug: false, + Region: "test_region", + Servers: config.ServerConfigurations{ + { + URL: testServer.URL, + Description: "Localhost for iaas_DefaultApi", + Variables: map[string]config.ServerVariable{ + "region": { + DefaultValue: "test_region.", + EnumValues: []string{ + "test_region.", + }, + }, + }, + }, + }, + OperationServers: map[string]config.ServerConfigurations{}, + } + apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication()) + if err != nil { + t.Fatalf("creating API client: %v", err) + } + + projectId := "projectId" + imageId := "imageId" + + resp, reqErr := apiClient.UpdateImageScopePublic(context.Background(), projectId, imageId).Execute() + + if reqErr != nil { + t.Fatalf("error in call: %v", reqErr) + } + if resp == nil { + t.Fatalf("response not present") + } + }) + t.Run("Test DefaultApiService UpdateImageShare", func(t *testing.T) { path := "/v1beta1/projects/{projectId}/images/{imageId}/share" projectIdValue := "projectId" diff --git a/services/iaas/model_quota.go b/services/iaas/model_quota.go new file mode 100644 index 00000000..e0412dc2 --- /dev/null +++ b/services/iaas/model_quota.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the Quota type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &Quota{} + +// Quota Object that represents a single resource quota. +type Quota struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _Quota Quota + +// NewQuota instantiates a new Quota object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuota(limit *int64, usage *int64) *Quota { + this := Quota{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaWithDefaults instantiates a new Quota object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaWithDefaults() *Quota { + this := Quota{} + return &this +} + +// GetLimit returns the Limit field value +func (o *Quota) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *Quota) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *Quota) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *Quota) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *Quota) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *Quota) SetUsage(v *int64) { + o.Usage = v +} + +func (o Quota) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuota struct { + value *Quota + isSet bool +} + +func (v NullableQuota) Get() *Quota { + return v.value +} + +func (v *NullableQuota) Set(val *Quota) { + v.value = val + v.isSet = true +} + +func (v NullableQuota) IsSet() bool { + return v.isSet +} + +func (v *NullableQuota) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuota(val *Quota) *NullableQuota { + return &NullableQuota{value: val, isSet: true} +} + +func (v NullableQuota) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuota) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list.go b/services/iaas/model_quota_list.go new file mode 100644 index 00000000..cb277f9a --- /dev/null +++ b/services/iaas/model_quota_list.go @@ -0,0 +1,418 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaList type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaList{} + +// QuotaList Object that represents the quotas for a project. +type QuotaList struct { + // REQUIRED + BackupGigabytes *QuotaListBackupGigabytes `json:"backupGigabytes"` + // REQUIRED + Backups *QuotaListBackups `json:"backups"` + // REQUIRED + Gigabytes *QuotaListGigabytes `json:"gigabytes"` + // REQUIRED + Networks *QuotaListNetworks `json:"networks"` + // REQUIRED + Nics *QuotaListNics `json:"nics"` + // REQUIRED + PublicIps *QuotaListPublicIps `json:"publicIps"` + // REQUIRED + Ram *QuotaListRam `json:"ram"` + // REQUIRED + SecurityGroupRules *QuotaListSecurityGroupRules `json:"securityGroupRules"` + // REQUIRED + SecurityGroups *QuotaListSecurityGroups `json:"securityGroups"` + // REQUIRED + Snapshots *QuotaListSnapshots `json:"snapshots"` + // REQUIRED + Vcpu *QuotaListVcpu `json:"vcpu"` + // REQUIRED + Volumes *QuotaListVolumes `json:"volumes"` +} + +type _QuotaList QuotaList + +// NewQuotaList instantiates a new QuotaList object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaList(backupGigabytes *QuotaListBackupGigabytes, backups *QuotaListBackups, gigabytes *QuotaListGigabytes, networks *QuotaListNetworks, nics *QuotaListNics, publicIps *QuotaListPublicIps, ram *QuotaListRam, securityGroupRules *QuotaListSecurityGroupRules, securityGroups *QuotaListSecurityGroups, snapshots *QuotaListSnapshots, vcpu *QuotaListVcpu, volumes *QuotaListVolumes) *QuotaList { + this := QuotaList{} + this.BackupGigabytes = backupGigabytes + this.Backups = backups + this.Gigabytes = gigabytes + this.Networks = networks + this.Nics = nics + this.PublicIps = publicIps + this.Ram = ram + this.SecurityGroupRules = securityGroupRules + this.SecurityGroups = securityGroups + this.Snapshots = snapshots + this.Vcpu = vcpu + this.Volumes = volumes + return &this +} + +// NewQuotaListWithDefaults instantiates a new QuotaList object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListWithDefaults() *QuotaList { + this := QuotaList{} + return &this +} + +// GetBackupGigabytes returns the BackupGigabytes field value +func (o *QuotaList) GetBackupGigabytes() *QuotaListBackupGigabytes { + if o == nil || IsNil(o.BackupGigabytes) { + var ret *QuotaListBackupGigabytes + return ret + } + + return o.BackupGigabytes +} + +// GetBackupGigabytesOk returns a tuple with the BackupGigabytes field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetBackupGigabytesOk() (*QuotaListBackupGigabytes, bool) { + if o == nil { + return nil, false + } + return o.BackupGigabytes, true +} + +// SetBackupGigabytes sets field value +func (o *QuotaList) SetBackupGigabytes(v *QuotaListBackupGigabytes) { + o.BackupGigabytes = v +} + +// GetBackups returns the Backups field value +func (o *QuotaList) GetBackups() *QuotaListBackups { + if o == nil || IsNil(o.Backups) { + var ret *QuotaListBackups + return ret + } + + return o.Backups +} + +// GetBackupsOk returns a tuple with the Backups field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetBackupsOk() (*QuotaListBackups, bool) { + if o == nil { + return nil, false + } + return o.Backups, true +} + +// SetBackups sets field value +func (o *QuotaList) SetBackups(v *QuotaListBackups) { + o.Backups = v +} + +// GetGigabytes returns the Gigabytes field value +func (o *QuotaList) GetGigabytes() *QuotaListGigabytes { + if o == nil || IsNil(o.Gigabytes) { + var ret *QuotaListGigabytes + return ret + } + + return o.Gigabytes +} + +// GetGigabytesOk returns a tuple with the Gigabytes field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetGigabytesOk() (*QuotaListGigabytes, bool) { + if o == nil { + return nil, false + } + return o.Gigabytes, true +} + +// SetGigabytes sets field value +func (o *QuotaList) SetGigabytes(v *QuotaListGigabytes) { + o.Gigabytes = v +} + +// GetNetworks returns the Networks field value +func (o *QuotaList) GetNetworks() *QuotaListNetworks { + if o == nil || IsNil(o.Networks) { + var ret *QuotaListNetworks + return ret + } + + return o.Networks +} + +// GetNetworksOk returns a tuple with the Networks field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetNetworksOk() (*QuotaListNetworks, bool) { + if o == nil { + return nil, false + } + return o.Networks, true +} + +// SetNetworks sets field value +func (o *QuotaList) SetNetworks(v *QuotaListNetworks) { + o.Networks = v +} + +// GetNics returns the Nics field value +func (o *QuotaList) GetNics() *QuotaListNics { + if o == nil || IsNil(o.Nics) { + var ret *QuotaListNics + return ret + } + + return o.Nics +} + +// GetNicsOk returns a tuple with the Nics field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetNicsOk() (*QuotaListNics, bool) { + if o == nil { + return nil, false + } + return o.Nics, true +} + +// SetNics sets field value +func (o *QuotaList) SetNics(v *QuotaListNics) { + o.Nics = v +} + +// GetPublicIps returns the PublicIps field value +func (o *QuotaList) GetPublicIps() *QuotaListPublicIps { + if o == nil || IsNil(o.PublicIps) { + var ret *QuotaListPublicIps + return ret + } + + return o.PublicIps +} + +// GetPublicIpsOk returns a tuple with the PublicIps field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetPublicIpsOk() (*QuotaListPublicIps, bool) { + if o == nil { + return nil, false + } + return o.PublicIps, true +} + +// SetPublicIps sets field value +func (o *QuotaList) SetPublicIps(v *QuotaListPublicIps) { + o.PublicIps = v +} + +// GetRam returns the Ram field value +func (o *QuotaList) GetRam() *QuotaListRam { + if o == nil || IsNil(o.Ram) { + var ret *QuotaListRam + return ret + } + + return o.Ram +} + +// GetRamOk returns a tuple with the Ram field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetRamOk() (*QuotaListRam, bool) { + if o == nil { + return nil, false + } + return o.Ram, true +} + +// SetRam sets field value +func (o *QuotaList) SetRam(v *QuotaListRam) { + o.Ram = v +} + +// GetSecurityGroupRules returns the SecurityGroupRules field value +func (o *QuotaList) GetSecurityGroupRules() *QuotaListSecurityGroupRules { + if o == nil || IsNil(o.SecurityGroupRules) { + var ret *QuotaListSecurityGroupRules + return ret + } + + return o.SecurityGroupRules +} + +// GetSecurityGroupRulesOk returns a tuple with the SecurityGroupRules field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetSecurityGroupRulesOk() (*QuotaListSecurityGroupRules, bool) { + if o == nil { + return nil, false + } + return o.SecurityGroupRules, true +} + +// SetSecurityGroupRules sets field value +func (o *QuotaList) SetSecurityGroupRules(v *QuotaListSecurityGroupRules) { + o.SecurityGroupRules = v +} + +// GetSecurityGroups returns the SecurityGroups field value +func (o *QuotaList) GetSecurityGroups() *QuotaListSecurityGroups { + if o == nil || IsNil(o.SecurityGroups) { + var ret *QuotaListSecurityGroups + return ret + } + + return o.SecurityGroups +} + +// GetSecurityGroupsOk returns a tuple with the SecurityGroups field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetSecurityGroupsOk() (*QuotaListSecurityGroups, bool) { + if o == nil { + return nil, false + } + return o.SecurityGroups, true +} + +// SetSecurityGroups sets field value +func (o *QuotaList) SetSecurityGroups(v *QuotaListSecurityGroups) { + o.SecurityGroups = v +} + +// GetSnapshots returns the Snapshots field value +func (o *QuotaList) GetSnapshots() *QuotaListSnapshots { + if o == nil || IsNil(o.Snapshots) { + var ret *QuotaListSnapshots + return ret + } + + return o.Snapshots +} + +// GetSnapshotsOk returns a tuple with the Snapshots field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetSnapshotsOk() (*QuotaListSnapshots, bool) { + if o == nil { + return nil, false + } + return o.Snapshots, true +} + +// SetSnapshots sets field value +func (o *QuotaList) SetSnapshots(v *QuotaListSnapshots) { + o.Snapshots = v +} + +// GetVcpu returns the Vcpu field value +func (o *QuotaList) GetVcpu() *QuotaListVcpu { + if o == nil || IsNil(o.Vcpu) { + var ret *QuotaListVcpu + return ret + } + + return o.Vcpu +} + +// GetVcpuOk returns a tuple with the Vcpu field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetVcpuOk() (*QuotaListVcpu, bool) { + if o == nil { + return nil, false + } + return o.Vcpu, true +} + +// SetVcpu sets field value +func (o *QuotaList) SetVcpu(v *QuotaListVcpu) { + o.Vcpu = v +} + +// GetVolumes returns the Volumes field value +func (o *QuotaList) GetVolumes() *QuotaListVolumes { + if o == nil || IsNil(o.Volumes) { + var ret *QuotaListVolumes + return ret + } + + return o.Volumes +} + +// GetVolumesOk returns a tuple with the Volumes field value +// and a boolean to check if the value has been set. +func (o *QuotaList) GetVolumesOk() (*QuotaListVolumes, bool) { + if o == nil { + return nil, false + } + return o.Volumes, true +} + +// SetVolumes sets field value +func (o *QuotaList) SetVolumes(v *QuotaListVolumes) { + o.Volumes = v +} + +func (o QuotaList) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["backupGigabytes"] = o.BackupGigabytes + toSerialize["backups"] = o.Backups + toSerialize["gigabytes"] = o.Gigabytes + toSerialize["networks"] = o.Networks + toSerialize["nics"] = o.Nics + toSerialize["publicIps"] = o.PublicIps + toSerialize["ram"] = o.Ram + toSerialize["securityGroupRules"] = o.SecurityGroupRules + toSerialize["securityGroups"] = o.SecurityGroups + toSerialize["snapshots"] = o.Snapshots + toSerialize["vcpu"] = o.Vcpu + toSerialize["volumes"] = o.Volumes + return toSerialize, nil +} + +type NullableQuotaList struct { + value *QuotaList + isSet bool +} + +func (v NullableQuotaList) Get() *QuotaList { + return v.value +} + +func (v *NullableQuotaList) Set(val *QuotaList) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaList) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaList) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaList(val *QuotaList) *NullableQuotaList { + return &NullableQuotaList{value: val, isSet: true} +} + +func (v NullableQuotaList) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaList) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_backup_gigabytes.go b/services/iaas/model_quota_list_backup_gigabytes.go new file mode 100644 index 00000000..533bd739 --- /dev/null +++ b/services/iaas/model_quota_list_backup_gigabytes.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListBackupGigabytes type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListBackupGigabytes{} + +// QuotaListBackupGigabytes Total size in GiB of backups. +type QuotaListBackupGigabytes struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListBackupGigabytes QuotaListBackupGigabytes + +// NewQuotaListBackupGigabytes instantiates a new QuotaListBackupGigabytes object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListBackupGigabytes(limit *int64, usage *int64) *QuotaListBackupGigabytes { + this := QuotaListBackupGigabytes{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListBackupGigabytesWithDefaults instantiates a new QuotaListBackupGigabytes object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListBackupGigabytesWithDefaults() *QuotaListBackupGigabytes { + this := QuotaListBackupGigabytes{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListBackupGigabytes) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListBackupGigabytes) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListBackupGigabytes) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListBackupGigabytes) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListBackupGigabytes) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListBackupGigabytes) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListBackupGigabytes) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListBackupGigabytes struct { + value *QuotaListBackupGigabytes + isSet bool +} + +func (v NullableQuotaListBackupGigabytes) Get() *QuotaListBackupGigabytes { + return v.value +} + +func (v *NullableQuotaListBackupGigabytes) Set(val *QuotaListBackupGigabytes) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListBackupGigabytes) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListBackupGigabytes) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListBackupGigabytes(val *QuotaListBackupGigabytes) *NullableQuotaListBackupGigabytes { + return &NullableQuotaListBackupGigabytes{value: val, isSet: true} +} + +func (v NullableQuotaListBackupGigabytes) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListBackupGigabytes) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_backups.go b/services/iaas/model_quota_list_backups.go new file mode 100644 index 00000000..b2d12d61 --- /dev/null +++ b/services/iaas/model_quota_list_backups.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListBackups type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListBackups{} + +// QuotaListBackups Number of backups. +type QuotaListBackups struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListBackups QuotaListBackups + +// NewQuotaListBackups instantiates a new QuotaListBackups object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListBackups(limit *int64, usage *int64) *QuotaListBackups { + this := QuotaListBackups{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListBackupsWithDefaults instantiates a new QuotaListBackups object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListBackupsWithDefaults() *QuotaListBackups { + this := QuotaListBackups{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListBackups) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListBackups) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListBackups) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListBackups) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListBackups) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListBackups) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListBackups) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListBackups struct { + value *QuotaListBackups + isSet bool +} + +func (v NullableQuotaListBackups) Get() *QuotaListBackups { + return v.value +} + +func (v *NullableQuotaListBackups) Set(val *QuotaListBackups) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListBackups) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListBackups) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListBackups(val *QuotaListBackups) *NullableQuotaListBackups { + return &NullableQuotaListBackups{value: val, isSet: true} +} + +func (v NullableQuotaListBackups) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListBackups) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_gigabytes.go b/services/iaas/model_quota_list_gigabytes.go new file mode 100644 index 00000000..ee40de71 --- /dev/null +++ b/services/iaas/model_quota_list_gigabytes.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListGigabytes type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListGigabytes{} + +// QuotaListGigabytes Total size in GiB of volumes and snapshots. +type QuotaListGigabytes struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListGigabytes QuotaListGigabytes + +// NewQuotaListGigabytes instantiates a new QuotaListGigabytes object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListGigabytes(limit *int64, usage *int64) *QuotaListGigabytes { + this := QuotaListGigabytes{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListGigabytesWithDefaults instantiates a new QuotaListGigabytes object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListGigabytesWithDefaults() *QuotaListGigabytes { + this := QuotaListGigabytes{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListGigabytes) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListGigabytes) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListGigabytes) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListGigabytes) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListGigabytes) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListGigabytes) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListGigabytes) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListGigabytes struct { + value *QuotaListGigabytes + isSet bool +} + +func (v NullableQuotaListGigabytes) Get() *QuotaListGigabytes { + return v.value +} + +func (v *NullableQuotaListGigabytes) Set(val *QuotaListGigabytes) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListGigabytes) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListGigabytes) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListGigabytes(val *QuotaListGigabytes) *NullableQuotaListGigabytes { + return &NullableQuotaListGigabytes{value: val, isSet: true} +} + +func (v NullableQuotaListGigabytes) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListGigabytes) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_networks.go b/services/iaas/model_quota_list_networks.go new file mode 100644 index 00000000..664c4067 --- /dev/null +++ b/services/iaas/model_quota_list_networks.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListNetworks type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListNetworks{} + +// QuotaListNetworks Number of networks. +type QuotaListNetworks struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListNetworks QuotaListNetworks + +// NewQuotaListNetworks instantiates a new QuotaListNetworks object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListNetworks(limit *int64, usage *int64) *QuotaListNetworks { + this := QuotaListNetworks{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListNetworksWithDefaults instantiates a new QuotaListNetworks object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListNetworksWithDefaults() *QuotaListNetworks { + this := QuotaListNetworks{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListNetworks) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListNetworks) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListNetworks) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListNetworks) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListNetworks) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListNetworks) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListNetworks) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListNetworks struct { + value *QuotaListNetworks + isSet bool +} + +func (v NullableQuotaListNetworks) Get() *QuotaListNetworks { + return v.value +} + +func (v *NullableQuotaListNetworks) Set(val *QuotaListNetworks) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListNetworks) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListNetworks) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListNetworks(val *QuotaListNetworks) *NullableQuotaListNetworks { + return &NullableQuotaListNetworks{value: val, isSet: true} +} + +func (v NullableQuotaListNetworks) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListNetworks) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_nics.go b/services/iaas/model_quota_list_nics.go new file mode 100644 index 00000000..21114db7 --- /dev/null +++ b/services/iaas/model_quota_list_nics.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListNics type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListNics{} + +// QuotaListNics Number of network interfaces. +type QuotaListNics struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListNics QuotaListNics + +// NewQuotaListNics instantiates a new QuotaListNics object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListNics(limit *int64, usage *int64) *QuotaListNics { + this := QuotaListNics{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListNicsWithDefaults instantiates a new QuotaListNics object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListNicsWithDefaults() *QuotaListNics { + this := QuotaListNics{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListNics) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListNics) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListNics) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListNics) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListNics) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListNics) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListNics) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListNics struct { + value *QuotaListNics + isSet bool +} + +func (v NullableQuotaListNics) Get() *QuotaListNics { + return v.value +} + +func (v *NullableQuotaListNics) Set(val *QuotaListNics) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListNics) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListNics) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListNics(val *QuotaListNics) *NullableQuotaListNics { + return &NullableQuotaListNics{value: val, isSet: true} +} + +func (v NullableQuotaListNics) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListNics) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_public_ips.go b/services/iaas/model_quota_list_public_ips.go new file mode 100644 index 00000000..345a33f5 --- /dev/null +++ b/services/iaas/model_quota_list_public_ips.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListPublicIps type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListPublicIps{} + +// QuotaListPublicIps Number of public IP addresses. +type QuotaListPublicIps struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListPublicIps QuotaListPublicIps + +// NewQuotaListPublicIps instantiates a new QuotaListPublicIps object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListPublicIps(limit *int64, usage *int64) *QuotaListPublicIps { + this := QuotaListPublicIps{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListPublicIpsWithDefaults instantiates a new QuotaListPublicIps object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListPublicIpsWithDefaults() *QuotaListPublicIps { + this := QuotaListPublicIps{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListPublicIps) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListPublicIps) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListPublicIps) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListPublicIps) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListPublicIps) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListPublicIps) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListPublicIps) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListPublicIps struct { + value *QuotaListPublicIps + isSet bool +} + +func (v NullableQuotaListPublicIps) Get() *QuotaListPublicIps { + return v.value +} + +func (v *NullableQuotaListPublicIps) Set(val *QuotaListPublicIps) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListPublicIps) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListPublicIps) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListPublicIps(val *QuotaListPublicIps) *NullableQuotaListPublicIps { + return &NullableQuotaListPublicIps{value: val, isSet: true} +} + +func (v NullableQuotaListPublicIps) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListPublicIps) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_ram.go b/services/iaas/model_quota_list_ram.go new file mode 100644 index 00000000..89635769 --- /dev/null +++ b/services/iaas/model_quota_list_ram.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListRam type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListRam{} + +// QuotaListRam Amount of server RAM in MiB. +type QuotaListRam struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListRam QuotaListRam + +// NewQuotaListRam instantiates a new QuotaListRam object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListRam(limit *int64, usage *int64) *QuotaListRam { + this := QuotaListRam{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListRamWithDefaults instantiates a new QuotaListRam object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListRamWithDefaults() *QuotaListRam { + this := QuotaListRam{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListRam) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListRam) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListRam) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListRam) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListRam) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListRam) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListRam) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListRam struct { + value *QuotaListRam + isSet bool +} + +func (v NullableQuotaListRam) Get() *QuotaListRam { + return v.value +} + +func (v *NullableQuotaListRam) Set(val *QuotaListRam) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListRam) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListRam) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListRam(val *QuotaListRam) *NullableQuotaListRam { + return &NullableQuotaListRam{value: val, isSet: true} +} + +func (v NullableQuotaListRam) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListRam) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_response.go b/services/iaas/model_quota_list_response.go new file mode 100644 index 00000000..d1b047ff --- /dev/null +++ b/services/iaas/model_quota_list_response.go @@ -0,0 +1,110 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListResponse type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListResponse{} + +// QuotaListResponse Quotas list response. +type QuotaListResponse struct { + // REQUIRED + Quotas *QuotaList `json:"quotas"` +} + +type _QuotaListResponse QuotaListResponse + +// NewQuotaListResponse instantiates a new QuotaListResponse object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListResponse(quotas *QuotaList) *QuotaListResponse { + this := QuotaListResponse{} + this.Quotas = quotas + return &this +} + +// NewQuotaListResponseWithDefaults instantiates a new QuotaListResponse object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListResponseWithDefaults() *QuotaListResponse { + this := QuotaListResponse{} + return &this +} + +// GetQuotas returns the Quotas field value +func (o *QuotaListResponse) GetQuotas() *QuotaList { + if o == nil || IsNil(o.Quotas) { + var ret *QuotaList + return ret + } + + return o.Quotas +} + +// GetQuotasOk returns a tuple with the Quotas field value +// and a boolean to check if the value has been set. +func (o *QuotaListResponse) GetQuotasOk() (*QuotaList, bool) { + if o == nil { + return nil, false + } + return o.Quotas, true +} + +// SetQuotas sets field value +func (o *QuotaListResponse) SetQuotas(v *QuotaList) { + o.Quotas = v +} + +func (o QuotaListResponse) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["quotas"] = o.Quotas + return toSerialize, nil +} + +type NullableQuotaListResponse struct { + value *QuotaListResponse + isSet bool +} + +func (v NullableQuotaListResponse) Get() *QuotaListResponse { + return v.value +} + +func (v *NullableQuotaListResponse) Set(val *QuotaListResponse) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListResponse) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListResponse) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListResponse(val *QuotaListResponse) *NullableQuotaListResponse { + return &NullableQuotaListResponse{value: val, isSet: true} +} + +func (v NullableQuotaListResponse) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListResponse) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_security_group_rules.go b/services/iaas/model_quota_list_security_group_rules.go new file mode 100644 index 00000000..8cd449de --- /dev/null +++ b/services/iaas/model_quota_list_security_group_rules.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListSecurityGroupRules type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListSecurityGroupRules{} + +// QuotaListSecurityGroupRules Number of security group rules. +type QuotaListSecurityGroupRules struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListSecurityGroupRules QuotaListSecurityGroupRules + +// NewQuotaListSecurityGroupRules instantiates a new QuotaListSecurityGroupRules object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListSecurityGroupRules(limit *int64, usage *int64) *QuotaListSecurityGroupRules { + this := QuotaListSecurityGroupRules{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListSecurityGroupRulesWithDefaults instantiates a new QuotaListSecurityGroupRules object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListSecurityGroupRulesWithDefaults() *QuotaListSecurityGroupRules { + this := QuotaListSecurityGroupRules{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListSecurityGroupRules) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListSecurityGroupRules) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListSecurityGroupRules) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListSecurityGroupRules) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListSecurityGroupRules) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListSecurityGroupRules) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListSecurityGroupRules) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListSecurityGroupRules struct { + value *QuotaListSecurityGroupRules + isSet bool +} + +func (v NullableQuotaListSecurityGroupRules) Get() *QuotaListSecurityGroupRules { + return v.value +} + +func (v *NullableQuotaListSecurityGroupRules) Set(val *QuotaListSecurityGroupRules) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListSecurityGroupRules) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListSecurityGroupRules) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListSecurityGroupRules(val *QuotaListSecurityGroupRules) *NullableQuotaListSecurityGroupRules { + return &NullableQuotaListSecurityGroupRules{value: val, isSet: true} +} + +func (v NullableQuotaListSecurityGroupRules) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListSecurityGroupRules) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_security_groups.go b/services/iaas/model_quota_list_security_groups.go new file mode 100644 index 00000000..19e79739 --- /dev/null +++ b/services/iaas/model_quota_list_security_groups.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListSecurityGroups type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListSecurityGroups{} + +// QuotaListSecurityGroups Number of security groups. +type QuotaListSecurityGroups struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListSecurityGroups QuotaListSecurityGroups + +// NewQuotaListSecurityGroups instantiates a new QuotaListSecurityGroups object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListSecurityGroups(limit *int64, usage *int64) *QuotaListSecurityGroups { + this := QuotaListSecurityGroups{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListSecurityGroupsWithDefaults instantiates a new QuotaListSecurityGroups object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListSecurityGroupsWithDefaults() *QuotaListSecurityGroups { + this := QuotaListSecurityGroups{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListSecurityGroups) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListSecurityGroups) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListSecurityGroups) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListSecurityGroups) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListSecurityGroups) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListSecurityGroups) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListSecurityGroups) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListSecurityGroups struct { + value *QuotaListSecurityGroups + isSet bool +} + +func (v NullableQuotaListSecurityGroups) Get() *QuotaListSecurityGroups { + return v.value +} + +func (v *NullableQuotaListSecurityGroups) Set(val *QuotaListSecurityGroups) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListSecurityGroups) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListSecurityGroups) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListSecurityGroups(val *QuotaListSecurityGroups) *NullableQuotaListSecurityGroups { + return &NullableQuotaListSecurityGroups{value: val, isSet: true} +} + +func (v NullableQuotaListSecurityGroups) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListSecurityGroups) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_snapshots.go b/services/iaas/model_quota_list_snapshots.go new file mode 100644 index 00000000..00cbab62 --- /dev/null +++ b/services/iaas/model_quota_list_snapshots.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListSnapshots type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListSnapshots{} + +// QuotaListSnapshots Number of snapshots. +type QuotaListSnapshots struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListSnapshots QuotaListSnapshots + +// NewQuotaListSnapshots instantiates a new QuotaListSnapshots object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListSnapshots(limit *int64, usage *int64) *QuotaListSnapshots { + this := QuotaListSnapshots{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListSnapshotsWithDefaults instantiates a new QuotaListSnapshots object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListSnapshotsWithDefaults() *QuotaListSnapshots { + this := QuotaListSnapshots{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListSnapshots) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListSnapshots) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListSnapshots) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListSnapshots) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListSnapshots) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListSnapshots) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListSnapshots) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListSnapshots struct { + value *QuotaListSnapshots + isSet bool +} + +func (v NullableQuotaListSnapshots) Get() *QuotaListSnapshots { + return v.value +} + +func (v *NullableQuotaListSnapshots) Set(val *QuotaListSnapshots) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListSnapshots) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListSnapshots) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListSnapshots(val *QuotaListSnapshots) *NullableQuotaListSnapshots { + return &NullableQuotaListSnapshots{value: val, isSet: true} +} + +func (v NullableQuotaListSnapshots) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListSnapshots) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_vcpu.go b/services/iaas/model_quota_list_vcpu.go new file mode 100644 index 00000000..cec476cd --- /dev/null +++ b/services/iaas/model_quota_list_vcpu.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListVcpu type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListVcpu{} + +// QuotaListVcpu Number of server cores. +type QuotaListVcpu struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListVcpu QuotaListVcpu + +// NewQuotaListVcpu instantiates a new QuotaListVcpu object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListVcpu(limit *int64, usage *int64) *QuotaListVcpu { + this := QuotaListVcpu{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListVcpuWithDefaults instantiates a new QuotaListVcpu object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListVcpuWithDefaults() *QuotaListVcpu { + this := QuotaListVcpu{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListVcpu) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListVcpu) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListVcpu) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListVcpu) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListVcpu) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListVcpu) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListVcpu) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListVcpu struct { + value *QuotaListVcpu + isSet bool +} + +func (v NullableQuotaListVcpu) Get() *QuotaListVcpu { + return v.value +} + +func (v *NullableQuotaListVcpu) Set(val *QuotaListVcpu) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListVcpu) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListVcpu) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListVcpu(val *QuotaListVcpu) *NullableQuotaListVcpu { + return &NullableQuotaListVcpu{value: val, isSet: true} +} + +func (v NullableQuotaListVcpu) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListVcpu) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/services/iaas/model_quota_list_volumes.go b/services/iaas/model_quota_list_volumes.go new file mode 100644 index 00000000..f4fc9933 --- /dev/null +++ b/services/iaas/model_quota_list_volumes.go @@ -0,0 +1,138 @@ +/* +IaaS-API + +This API allows you to create and modify IaaS resources. + +API version: 1beta1 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package iaas + +import ( + "encoding/json" +) + +// checks if the QuotaListVolumes type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &QuotaListVolumes{} + +// QuotaListVolumes Number of volumes. +type QuotaListVolumes struct { + // REQUIRED + Limit *int64 `json:"limit"` + // REQUIRED + Usage *int64 `json:"usage"` +} + +type _QuotaListVolumes QuotaListVolumes + +// NewQuotaListVolumes instantiates a new QuotaListVolumes object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewQuotaListVolumes(limit *int64, usage *int64) *QuotaListVolumes { + this := QuotaListVolumes{} + this.Limit = limit + this.Usage = usage + return &this +} + +// NewQuotaListVolumesWithDefaults instantiates a new QuotaListVolumes object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewQuotaListVolumesWithDefaults() *QuotaListVolumes { + this := QuotaListVolumes{} + return &this +} + +// GetLimit returns the Limit field value +func (o *QuotaListVolumes) GetLimit() *int64 { + if o == nil || IsNil(o.Limit) { + var ret *int64 + return ret + } + + return o.Limit +} + +// GetLimitOk returns a tuple with the Limit field value +// and a boolean to check if the value has been set. +func (o *QuotaListVolumes) GetLimitOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Limit, true +} + +// SetLimit sets field value +func (o *QuotaListVolumes) SetLimit(v *int64) { + o.Limit = v +} + +// GetUsage returns the Usage field value +func (o *QuotaListVolumes) GetUsage() *int64 { + if o == nil || IsNil(o.Usage) { + var ret *int64 + return ret + } + + return o.Usage +} + +// GetUsageOk returns a tuple with the Usage field value +// and a boolean to check if the value has been set. +func (o *QuotaListVolumes) GetUsageOk() (*int64, bool) { + if o == nil { + return nil, false + } + return o.Usage, true +} + +// SetUsage sets field value +func (o *QuotaListVolumes) SetUsage(v *int64) { + o.Usage = v +} + +func (o QuotaListVolumes) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["limit"] = o.Limit + toSerialize["usage"] = o.Usage + return toSerialize, nil +} + +type NullableQuotaListVolumes struct { + value *QuotaListVolumes + isSet bool +} + +func (v NullableQuotaListVolumes) Get() *QuotaListVolumes { + return v.value +} + +func (v *NullableQuotaListVolumes) Set(val *QuotaListVolumes) { + v.value = val + v.isSet = true +} + +func (v NullableQuotaListVolumes) IsSet() bool { + return v.isSet +} + +func (v *NullableQuotaListVolumes) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableQuotaListVolumes(val *QuotaListVolumes) *NullableQuotaListVolumes { + return &NullableQuotaListVolumes{value: val, isSet: true} +} + +func (v NullableQuotaListVolumes) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableQuotaListVolumes) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} From 360896f4b130d4477a94ff182eada44dac7de45f Mon Sep 17 00:00:00 2001 From: Vicente Pinto Date: Fri, 20 Dec 2024 09:15:32 +0000 Subject: [PATCH 2/2] Update CHANGELOG --- CHANGELOG.md | 6 +++++- services/iaas/CHANGELOG.md | 5 +++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3918a75f..94c8520b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,10 @@ ## Release (2025-xx-yy) + - `postgresflex`: [0.16.1](services/postgresflex/CHANGELOG.md#v0161-2025-xx-yy) - **Bugfix:** Correctly handle nullable attributes in model types +- `iaas`: [v0.19.0](services/iaas/CHANGELOG.md#v0190-2024-12-20) + - **Feature:** Add method to list quotas: `ListQuotas` + - **Feature:** Add methods to change image scope: `UpdateImageScopeLocal` and `UpdateImageScopePublic` ## Release (2024-12-17) @@ -10,7 +14,7 @@ > > Use `github.com/stackitcloud/stackit-sdk-go/services/authorization` instead. -- `iaas`: [v0.18](services/iaas/CHANGELOG.md#v0180-2024-12-16) +- `iaas`: [v0.18.0](services/iaas/CHANGELOG.md#v0180-2024-12-16) - **Feature:** Add waiters for async operations: `UploadImageWaitHandler` and `DeleteImageWaitHandler` - `iaas`: [v0.17.0](services/iaas/CHANGELOG.md#v0170-2024-12-16) - **Feature:** Add new methods to manage affinity groups: `CreateAffinityGroup`, `DeleteAffinityGroup`, `GetAffinityGroup`, and `ListAffinityGroup` diff --git a/services/iaas/CHANGELOG.md b/services/iaas/CHANGELOG.md index 7d9d448c..075e2f70 100644 --- a/services/iaas/CHANGELOG.md +++ b/services/iaas/CHANGELOG.md @@ -1,3 +1,8 @@ +## v0.19.0 (2024-12-20) + +- **Feature:** Add method to list quotas: `ListQuotas` +- **Feature:** Add methods to change image scope: `UpdateImageScopeLocal` and `UpdateImageScopePublic` + ## v0.18.0 (2024-12-16) - **Feature:** Add waiters for async operations: `UploadImageWaitHandler` and `DeleteImageWaitHandler`