From 3adfa2af9455bfdf923d626e89e4c307e3a9cd24 Mon Sep 17 00:00:00 2001 From: Sean Yeh <109418+seanyeh@users.noreply.github.com> Date: Thu, 17 Oct 2024 15:52:38 -0500 Subject: [PATCH 1/3] tmp --- Makefile | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/Makefile b/Makefile index 6aab717..e6ab8ba 100644 --- a/Makefile +++ b/Makefile @@ -43,6 +43,13 @@ build_debug:: ensure_go build_python:: PYPI_VERSION=$(PYTHON_SDK_VERSION) ./scripts/build_python_sdk.sh +build_typescript:: + cd sdk/typescript && \ + npm i && npm run build && \ + cp ../../README.md ../../LICENSE package.json package-lock.json ./bin/ && \ + sed -i.bak -e "s/\$${VERSION}/$(VERSION)/g" ./bin/package.json && \ + rm -rf ./bin/tests/* + test_go:: build_go cd sdk && ${GO} test --timeout 30m -short -count 1 -parallel ${CONCURRENCY} ./... From 1283b641a9d84ebd59842668d6d71d7fdca3c8ad Mon Sep 17 00:00:00 2001 From: Sean Yeh <109418+seanyeh@users.noreply.github.com> Date: Thu, 17 Oct 2024 15:52:38 -0500 Subject: [PATCH 2/3] Add clone environment --- sdk/go/api_esc_extensions.go | 23 +++++++++++ sdk/python/pulumi_esc_sdk/esc_client.py | 19 +++++++++ sdk/swagger.yaml | 53 ++++++++++++++++++++++++- sdk/typescript/esc/index.ts | 40 +++++++++++++++++++ 4 files changed, 134 insertions(+), 1 deletion(-) diff --git a/sdk/go/api_esc_extensions.go b/sdk/go/api_esc_extensions.go index 73fa168..e144fb1 100644 --- a/sdk/go/api_esc_extensions.go +++ b/sdk/go/api_esc_extensions.go @@ -153,6 +153,29 @@ func (c *EscClient) CreateEnvironment(ctx context.Context, org, projectName, env return err } +type CloneEnvironmentOptions struct { + Version int32 + PreserveHistory bool + PreserveAccess bool + PreserveEnvironmentTags bool + PreserveRevisionTags bool +} + +// CloneEnvironment clones an existing environment into a new environment. +func (c *EscClient) CloneEnvironment(ctx context.Context, org, srcProjectName, srcEnvName, destProjectName, destEnvName string, cloneEnvironmentOptions *CloneEnvironmentOptions) error { + cloneEnvironment := NewCloneEnvironment(destProjectName, destEnvName) + if cloneEnvironmentOptions.Version != 0 { + cloneEnvironment.Version = &cloneEnvironmentOptions.Version + } + cloneEnvironment.PreserveHistory = &cloneEnvironmentOptions.PreserveHistory + cloneEnvironment.PreserveAccess = &cloneEnvironmentOptions.PreserveAccess + cloneEnvironment.PreserveEnvironmentTags = &cloneEnvironmentOptions.PreserveEnvironmentTags + cloneEnvironment.PreserveRevisionTags = &cloneEnvironmentOptions.PreserveRevisionTags + + _, err := c.EscAPI.CloneEnvironment(ctx, org, srcProjectName, srcEnvName).CloneEnvironment(*cloneEnvironment).Execute() + return err +} + // UpdateEnvironmentYaml updates the environment with the given name in the given organization with the given YAML definition. func (c *EscClient) UpdateEnvironmentYaml(ctx context.Context, org, projectName, envName, yaml string) (*EnvironmentDiagnostics, error) { diags, _, err := c.EscAPI.UpdateEnvironmentYaml(ctx, org, projectName, envName).Body(yaml).Execute() diff --git a/sdk/python/pulumi_esc_sdk/esc_client.py b/sdk/python/pulumi_esc_sdk/esc_client.py index f1efc9f..d782bd6 100644 --- a/sdk/python/pulumi_esc_sdk/esc_client.py +++ b/sdk/python/pulumi_esc_sdk/esc_client.py @@ -139,6 +139,25 @@ def create_environment(self, org_name: str, project_name: str, env_name: str) -> createEnv = models.CreateEnvironment(project=project_name, name=env_name) return self.esc_api.create_environment(org_name, createEnv) + def clone_environment(self, org_name: str, src_project_name: str, src_env_name: str, dest_project_name: str, dest_env_name: str, clone_options: dict = {}) -> models.Environment: + """Clone an environment. + + :param org_name: The name of the organization. + :param src_project_name: The name of the source project. + :param src_env_name: The name of the source environment. + :param dest_project_name: The name of the destination project. + :param dest_env_name: The name of the destination environment. + :param clone_options: A dictionary containing clone options. + :key int version: Description of what option4 does. + :key bool preserve_access: Description of what option1 does. + :key bool preserve_environment_tags: Description of what option2 does. This option controls X. + :key bool preserve_history: Description of what option2 does. This option controls X. + :key bool preserve_revision_tags: Description + :return: The created environment.""" + + cloneEnv = models.CloneEnvironment(project=dest_project_name, name=dest_env_name, **clone_options) + return self.esc_api.clone_environment(org_name, src_project_name, src_env_name, cloneEnv) + def update_environment_yaml(self, org_name: str, project_name: str, env_name: str, yaml_body: str) -> models.EnvironmentDiagnostics: """Update an environment using the YAML body. diff --git a/sdk/swagger.yaml b/sdk/swagger.yaml index 9347928..fc9d067 100644 --- a/sdk/swagger.yaml +++ b/sdk/swagger.yaml @@ -108,6 +108,26 @@ components: required: - project - name + CloneEnvironment: + type: object + properties: + project: + $ref: "#/components/schemas/ProjectName" + name: + $ref: "#/components/schemas/EnvName" + version: + type: integer + preserveAccess: + type: boolean + preserveEnvironmentTags: + type: boolean + preserveHistory: + type: boolean + preserveRevisionTags: + type: boolean + required: + - project + - name ExprBuiltin: type: object properties: @@ -798,6 +818,38 @@ paths: $ref: "#/components/responses/InternalServerError" "default": $ref: "#/components/responses/InternalServerError" + /environments/{orgName}/{projectName}/{envName}/clone: + parameters: + - $ref: "#/components/parameters/orgName" + - $ref: "#/components/parameters/projectName" + - $ref: "#/components/parameters/envName" + post: + tags: + - esc + operationId: CloneEnvironment + summary: Clones an environment + description: Clones an environment + requestBody: + description: Clone environment + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/CloneEnvironment" + responses: + "204": + description: The environment was cloned successfully. + "400": + $ref: "#/components/responses/BadRequest" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "500": + $ref: "#/components/responses/InternalServerError" + "default": + $ref: "#/components/responses/InternalServerError" + /environments/{orgName}/yaml/check: parameters: - $ref: "#/components/parameters/orgName" @@ -1300,4 +1352,3 @@ paths: $ref: "#/components/responses/InternalServerError" "default": $ref: "#/components/responses/InternalServerError" - \ No newline at end of file diff --git a/sdk/typescript/esc/index.ts b/sdk/typescript/esc/index.ts index f1c6d25..edade1f 100644 --- a/sdk/typescript/esc/index.ts +++ b/sdk/typescript/esc/index.ts @@ -59,6 +59,14 @@ export interface EnvironmentPropertyResponse { value: any; } +export interface CloneEnvironmentOptions { + version?: number; + preserveHistory?: boolean; + preserveAccess?: boolean; + preserveEnvironmentTags?: boolean; + preserveRevisionTags?: boolean; +} + type KeyValueMap = { [key: string]: string }; /** @@ -314,6 +322,38 @@ export class EscApi { throw new Error(`Failed to create environment: ${resp.statusText}`); } + /** + * cloneEnvironment clones an environment + * @summary Clone environment + * @param {string} orgName Organization name + * @param {string} cloneProjectName Clone project name + * @param {string} cloneEnvName Clone environment name + * @param {string} destProjectName Destination project name + * @param {string} destEnvName Destionation environment name + * @returns {Promise} A promise that resolves when the environment is created + */ + async cloneEnvironment( + orgName: string, + srcProjectName: string, + srcEnvName: string, + destProjectName: string, + destEnvName: string, + cloneOptions: CloneEnvironmentOptions, + ): Promise { + const body = { + project: destProjectName, + name: destEnvName, + ...cloneOptions, + }; + + const resp = await this.rawApi.cloneEnvironment(orgName, srcProjectName, srcEnvName, body); + if (resp.status === 204) { + return; + } + + throw new Error(`Failed to clone environment: ${resp.statusText}`); + } + /** * updateEnvironmentYaml updates the environment definition from a YAML string. * @summary Update environment YAML From 5398104526067e1a3fe67f467c68e805a0373b11 Mon Sep 17 00:00:00 2001 From: Sean Yeh <109418+seanyeh@users.noreply.github.com> Date: Thu, 17 Oct 2024 15:52:38 -0500 Subject: [PATCH 3/3] Autogenerated --- sdk/go/.openapi-generator/FILES | 1 + sdk/go/api_esc.go | 198 ++++++++++ sdk/go/model_clone_environment.go | 367 ++++++++++++++++++ sdk/python/.openapi-generator/FILES | 1 + sdk/python/pulumi_esc_sdk/__init__.py | 1 + sdk/python/pulumi_esc_sdk/api/esc_api.py | 329 ++++++++++++++++ sdk/python/pulumi_esc_sdk/models/__init__.py | 1 + .../models/clone_environment.py | 116 ++++++ sdk/typescript/esc/raw/api.ts | 146 +++++++ 9 files changed, 1160 insertions(+) create mode 100644 sdk/go/model_clone_environment.go create mode 100644 sdk/python/pulumi_esc_sdk/models/clone_environment.py diff --git a/sdk/go/.openapi-generator/FILES b/sdk/go/.openapi-generator/FILES index 18cf27a..8c152ac 100644 --- a/sdk/go/.openapi-generator/FILES +++ b/sdk/go/.openapi-generator/FILES @@ -4,6 +4,7 @@ configuration.go model_access.go model_accessor.go model_check_environment.go +model_clone_environment.go model_create_environment.go model_create_environment_revision_tag.go model_create_environment_tag.go diff --git a/sdk/go/api_esc.go b/sdk/go/api_esc.go index 26b781e..f1b3529 100644 --- a/sdk/go/api_esc.go +++ b/sdk/go/api_esc.go @@ -215,6 +215,204 @@ func (a *EscAPIService) CheckEnvironmentYamlExecute(r ApiCheckEnvironmentYamlReq return localVarReturnValue, localVarHTTPResponse, nil } +type ApiCloneEnvironmentRequest struct { + ctx context.Context + ApiService *EscAPIService + orgName string + projectName string + envName string + cloneEnvironment *CloneEnvironment +} + +// Clone environment +func (r ApiCloneEnvironmentRequest) CloneEnvironment(cloneEnvironment CloneEnvironment) ApiCloneEnvironmentRequest { + r.cloneEnvironment = &cloneEnvironment + return r +} + +func (r ApiCloneEnvironmentRequest) Execute() (*http.Response, error) { + return r.ApiService.CloneEnvironmentExecute(r) +} + +/* +CloneEnvironment Clones an environment + +Clones an environment + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @param orgName Organization name + @param projectName Project name + @param envName Environment name + @return ApiCloneEnvironmentRequest +*/ +func (a *EscAPIService) CloneEnvironment(ctx context.Context, orgName string, projectName string, envName string) ApiCloneEnvironmentRequest { + return ApiCloneEnvironmentRequest{ + ApiService: a, + ctx: ctx, + orgName: orgName, + projectName: projectName, + envName: envName, + } +} + +// Execute executes the request +func (a *EscAPIService) CloneEnvironmentExecute(r ApiCloneEnvironmentRequest) (*http.Response, error) { + var ( + localVarHTTPMethod = http.MethodPost + localVarPostBody interface{} + formFiles []formFile + ) + + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "EscAPIService.CloneEnvironment") + if err != nil { + return nil, &GenericOpenAPIError{error: err.Error()} + } + + localVarPath := localBasePath + "/environments/{orgName}/{projectName}/{envName}/clone" + localVarPath = strings.Replace(localVarPath, "{"+"orgName"+"}", url.PathEscape(parameterValueToString(r.orgName, "orgName")), -1) + localVarPath = strings.Replace(localVarPath, "{"+"projectName"+"}", url.PathEscape(parameterValueToString(r.projectName, "projectName")), -1) + localVarPath = strings.Replace(localVarPath, "{"+"envName"+"}", url.PathEscape(parameterValueToString(r.envName, "envName")), -1) + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + if strlen(r.orgName) < 3 { + return nil, reportError("orgName must have at least 3 elements") + } + if strlen(r.orgName) > 40 { + return nil, reportError("orgName must have less than 40 elements") + } + if strlen(r.projectName) < 1 { + return nil, reportError("projectName must have at least 1 elements") + } + if strlen(r.projectName) > 100 { + return nil, reportError("projectName must have less than 100 elements") + } + if strlen(r.envName) < 1 { + return nil, reportError("envName must have at least 1 elements") + } + if strlen(r.envName) > 100 { + return nil, reportError("envName must have less than 100 elements") + } + if r.cloneEnvironment == nil { + return nil, reportError("cloneEnvironment is required and must be specified") + } + + // to determine the Content-Type header + localVarHTTPContentTypes := []string{"application/json"} + + // set Content-Type header + localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) + if localVarHTTPContentType != "" { + localVarHeaderParams["Content-Type"] = localVarHTTPContentType + } + + // to determine the Accept header + localVarHTTPHeaderAccepts := []string{"application/json"} + + // set Accept header + localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts) + if localVarHTTPHeaderAccept != "" { + localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept + } + parameterAddToHeaderOrQuery(localVarHeaderParams, "X-Pulumi-Source", "esc-sdk", "") + parameterAddToHeaderOrQuery(localVarHeaderParams, "User-Agent", userAgent, "") + // body params + localVarPostBody = r.cloneEnvironment + if r.ctx != nil { + // API Key Authentication + if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok { + if apiKey, ok := auth["Authorization"]; ok { + var key string + if apiKey.Prefix != "" { + key = apiKey.Prefix + " " + apiKey.Key + } else { + key = apiKey.Key + } + localVarHeaderParams["Authorization"] = key + } + } + } + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return nil, err + } + + localVarHTTPResponse, err := a.client.callAPI(req) + if err != nil || localVarHTTPResponse == nil { + return localVarHTTPResponse, err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return localVarHTTPResponse, err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &GenericOpenAPIError{ + body: localVarBody, + error: localVarHTTPResponse.Status, + } + if localVarHTTPResponse.StatusCode == 400 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.error = err.Error() + return localVarHTTPResponse, newErr + } + newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.model = v + return localVarHTTPResponse, newErr + } + if localVarHTTPResponse.StatusCode == 401 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.error = err.Error() + return localVarHTTPResponse, newErr + } + newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.model = v + return localVarHTTPResponse, newErr + } + if localVarHTTPResponse.StatusCode == 404 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.error = err.Error() + return localVarHTTPResponse, newErr + } + newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.model = v + return localVarHTTPResponse, newErr + } + if localVarHTTPResponse.StatusCode == 500 { + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.error = err.Error() + return localVarHTTPResponse, newErr + } + newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.model = v + return localVarHTTPResponse, newErr + } + var v Error + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.error = err.Error() + return localVarHTTPResponse, newErr + } + newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.model = v + return localVarHTTPResponse, newErr + } + + return localVarHTTPResponse, nil +} + type ApiCreateEnvironmentRequest struct { ctx context.Context ApiService *EscAPIService diff --git a/sdk/go/model_clone_environment.go b/sdk/go/model_clone_environment.go new file mode 100644 index 0000000..d2ec948 --- /dev/null +++ b/sdk/go/model_clone_environment.go @@ -0,0 +1,367 @@ +// Copyright 2024, Pulumi Corporation. All rights reserved. +/* +ESC (Environments, Secrets, Config) API + +Pulumi ESC allows you to compose and manage hierarchical collections of configuration and secrets and consume them in various ways. + +API version: 0.1.0 +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package esc_sdk + +import ( + "encoding/json" + "bytes" + "fmt" +) + +// checks if the CloneEnvironment type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &CloneEnvironment{} + +// CloneEnvironment struct for CloneEnvironment +type CloneEnvironment struct { + Project string `json:"project"` + Name string `json:"name"` + Version *int32 `json:"version,omitempty"` + PreserveAccess *bool `json:"preserveAccess,omitempty"` + PreserveEnvironmentTags *bool `json:"preserveEnvironmentTags,omitempty"` + PreserveHistory *bool `json:"preserveHistory,omitempty"` + PreserveRevisionTags *bool `json:"preserveRevisionTags,omitempty"` +} + +type _CloneEnvironment CloneEnvironment + +// NewCloneEnvironment instantiates a new CloneEnvironment 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 NewCloneEnvironment(project string, name string) *CloneEnvironment { + this := CloneEnvironment{} + this.Project = project + this.Name = name + return &this +} + +// NewCloneEnvironmentWithDefaults instantiates a new CloneEnvironment 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 NewCloneEnvironmentWithDefaults() *CloneEnvironment { + this := CloneEnvironment{} + return &this +} + +// GetProject returns the Project field value +func (o *CloneEnvironment) GetProject() string { + if o == nil { + var ret string + return ret + } + + return o.Project +} + +// GetProjectOk returns a tuple with the Project field value +// and a boolean to check if the value has been set. +func (o *CloneEnvironment) GetProjectOk() (*string, bool) { + if o == nil { + return nil, false + } + return &o.Project, true +} + +// SetProject sets field value +func (o *CloneEnvironment) SetProject(v string) { + o.Project = v +} + +// GetName returns the Name field value +func (o *CloneEnvironment) GetName() string { + if o == nil { + var ret string + return ret + } + + return o.Name +} + +// GetNameOk returns a tuple with the Name field value +// and a boolean to check if the value has been set. +func (o *CloneEnvironment) GetNameOk() (*string, bool) { + if o == nil { + return nil, false + } + return &o.Name, true +} + +// SetName sets field value +func (o *CloneEnvironment) SetName(v string) { + o.Name = v +} + +// GetVersion returns the Version field value if set, zero value otherwise. +func (o *CloneEnvironment) GetVersion() int32 { + if o == nil || IsNil(o.Version) { + var ret int32 + return ret + } + return *o.Version +} + +// GetVersionOk returns a tuple with the Version field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CloneEnvironment) GetVersionOk() (*int32, bool) { + if o == nil || IsNil(o.Version) { + return nil, false + } + return o.Version, true +} + +// HasVersion returns a boolean if a field has been set. +func (o *CloneEnvironment) HasVersion() bool { + if o != nil && !IsNil(o.Version) { + return true + } + + return false +} + +// SetVersion gets a reference to the given int32 and assigns it to the Version field. +func (o *CloneEnvironment) SetVersion(v int32) { + o.Version = &v +} + +// GetPreserveAccess returns the PreserveAccess field value if set, zero value otherwise. +func (o *CloneEnvironment) GetPreserveAccess() bool { + if o == nil || IsNil(o.PreserveAccess) { + var ret bool + return ret + } + return *o.PreserveAccess +} + +// GetPreserveAccessOk returns a tuple with the PreserveAccess field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CloneEnvironment) GetPreserveAccessOk() (*bool, bool) { + if o == nil || IsNil(o.PreserveAccess) { + return nil, false + } + return o.PreserveAccess, true +} + +// HasPreserveAccess returns a boolean if a field has been set. +func (o *CloneEnvironment) HasPreserveAccess() bool { + if o != nil && !IsNil(o.PreserveAccess) { + return true + } + + return false +} + +// SetPreserveAccess gets a reference to the given bool and assigns it to the PreserveAccess field. +func (o *CloneEnvironment) SetPreserveAccess(v bool) { + o.PreserveAccess = &v +} + +// GetPreserveEnvironmentTags returns the PreserveEnvironmentTags field value if set, zero value otherwise. +func (o *CloneEnvironment) GetPreserveEnvironmentTags() bool { + if o == nil || IsNil(o.PreserveEnvironmentTags) { + var ret bool + return ret + } + return *o.PreserveEnvironmentTags +} + +// GetPreserveEnvironmentTagsOk returns a tuple with the PreserveEnvironmentTags field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CloneEnvironment) GetPreserveEnvironmentTagsOk() (*bool, bool) { + if o == nil || IsNil(o.PreserveEnvironmentTags) { + return nil, false + } + return o.PreserveEnvironmentTags, true +} + +// HasPreserveEnvironmentTags returns a boolean if a field has been set. +func (o *CloneEnvironment) HasPreserveEnvironmentTags() bool { + if o != nil && !IsNil(o.PreserveEnvironmentTags) { + return true + } + + return false +} + +// SetPreserveEnvironmentTags gets a reference to the given bool and assigns it to the PreserveEnvironmentTags field. +func (o *CloneEnvironment) SetPreserveEnvironmentTags(v bool) { + o.PreserveEnvironmentTags = &v +} + +// GetPreserveHistory returns the PreserveHistory field value if set, zero value otherwise. +func (o *CloneEnvironment) GetPreserveHistory() bool { + if o == nil || IsNil(o.PreserveHistory) { + var ret bool + return ret + } + return *o.PreserveHistory +} + +// GetPreserveHistoryOk returns a tuple with the PreserveHistory field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CloneEnvironment) GetPreserveHistoryOk() (*bool, bool) { + if o == nil || IsNil(o.PreserveHistory) { + return nil, false + } + return o.PreserveHistory, true +} + +// HasPreserveHistory returns a boolean if a field has been set. +func (o *CloneEnvironment) HasPreserveHistory() bool { + if o != nil && !IsNil(o.PreserveHistory) { + return true + } + + return false +} + +// SetPreserveHistory gets a reference to the given bool and assigns it to the PreserveHistory field. +func (o *CloneEnvironment) SetPreserveHistory(v bool) { + o.PreserveHistory = &v +} + +// GetPreserveRevisionTags returns the PreserveRevisionTags field value if set, zero value otherwise. +func (o *CloneEnvironment) GetPreserveRevisionTags() bool { + if o == nil || IsNil(o.PreserveRevisionTags) { + var ret bool + return ret + } + return *o.PreserveRevisionTags +} + +// GetPreserveRevisionTagsOk returns a tuple with the PreserveRevisionTags field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CloneEnvironment) GetPreserveRevisionTagsOk() (*bool, bool) { + if o == nil || IsNil(o.PreserveRevisionTags) { + return nil, false + } + return o.PreserveRevisionTags, true +} + +// HasPreserveRevisionTags returns a boolean if a field has been set. +func (o *CloneEnvironment) HasPreserveRevisionTags() bool { + if o != nil && !IsNil(o.PreserveRevisionTags) { + return true + } + + return false +} + +// SetPreserveRevisionTags gets a reference to the given bool and assigns it to the PreserveRevisionTags field. +func (o *CloneEnvironment) SetPreserveRevisionTags(v bool) { + o.PreserveRevisionTags = &v +} + +func (o CloneEnvironment) MarshalJSON() ([]byte, error) { + toSerialize,err := o.ToMap() + if err != nil { + return []byte{}, err + } + return json.Marshal(toSerialize) +} + +func (o CloneEnvironment) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + toSerialize["project"] = o.Project + toSerialize["name"] = o.Name + if !IsNil(o.Version) { + toSerialize["version"] = o.Version + } + if !IsNil(o.PreserveAccess) { + toSerialize["preserveAccess"] = o.PreserveAccess + } + if !IsNil(o.PreserveEnvironmentTags) { + toSerialize["preserveEnvironmentTags"] = o.PreserveEnvironmentTags + } + if !IsNil(o.PreserveHistory) { + toSerialize["preserveHistory"] = o.PreserveHistory + } + if !IsNil(o.PreserveRevisionTags) { + toSerialize["preserveRevisionTags"] = o.PreserveRevisionTags + } + return toSerialize, nil +} + +func (o *CloneEnvironment) UnmarshalJSON(data []byte) (err error) { + // This validates that all required properties are included in the JSON object + // by unmarshalling the object into a generic map with string keys and checking + // that every required field exists as a key in the generic map. + requiredProperties := []string{ + "project", + "name", + } + + allProperties := make(map[string]interface{}) + + err = json.Unmarshal(data, &allProperties) + + if err != nil { + return err; + } + + for _, requiredProperty := range(requiredProperties) { + if _, exists := allProperties[requiredProperty]; !exists { + return fmt.Errorf("no value given for required property %v", requiredProperty) + } + } + + varCloneEnvironment := _CloneEnvironment{} + + decoder := json.NewDecoder(bytes.NewReader(data)) + decoder.DisallowUnknownFields() + err = decoder.Decode(&varCloneEnvironment) + + if err != nil { + return err + } + + *o = CloneEnvironment(varCloneEnvironment) + + return err +} + +type NullableCloneEnvironment struct { + value *CloneEnvironment + isSet bool +} + +func (v NullableCloneEnvironment) Get() *CloneEnvironment { + return v.value +} + +func (v *NullableCloneEnvironment) Set(val *CloneEnvironment) { + v.value = val + v.isSet = true +} + +func (v NullableCloneEnvironment) IsSet() bool { + return v.isSet +} + +func (v *NullableCloneEnvironment) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableCloneEnvironment(val *CloneEnvironment) *NullableCloneEnvironment { + return &NullableCloneEnvironment{value: val, isSet: true} +} + +func (v NullableCloneEnvironment) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableCloneEnvironment) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} + + diff --git a/sdk/python/.openapi-generator/FILES b/sdk/python/.openapi-generator/FILES index 7a10c53..5152e71 100644 --- a/sdk/python/.openapi-generator/FILES +++ b/sdk/python/.openapi-generator/FILES @@ -10,6 +10,7 @@ pulumi_esc_sdk/models/__init__.py pulumi_esc_sdk/models/access.py pulumi_esc_sdk/models/accessor.py pulumi_esc_sdk/models/check_environment.py +pulumi_esc_sdk/models/clone_environment.py pulumi_esc_sdk/models/create_environment.py pulumi_esc_sdk/models/create_environment_revision_tag.py pulumi_esc_sdk/models/create_environment_tag.py diff --git a/sdk/python/pulumi_esc_sdk/__init__.py b/sdk/python/pulumi_esc_sdk/__init__.py index 660e3e7..7b9c736 100644 --- a/sdk/python/pulumi_esc_sdk/__init__.py +++ b/sdk/python/pulumi_esc_sdk/__init__.py @@ -39,6 +39,7 @@ from pulumi_esc_sdk.models.access import Access from pulumi_esc_sdk.models.accessor import Accessor from pulumi_esc_sdk.models.check_environment import CheckEnvironment +from pulumi_esc_sdk.models.clone_environment import CloneEnvironment from pulumi_esc_sdk.models.create_environment import CreateEnvironment from pulumi_esc_sdk.models.create_environment_revision_tag import CreateEnvironmentRevisionTag from pulumi_esc_sdk.models.create_environment_tag import CreateEnvironmentTag diff --git a/sdk/python/pulumi_esc_sdk/api/esc_api.py b/sdk/python/pulumi_esc_sdk/api/esc_api.py index 9cd6f84..35429ae 100644 --- a/sdk/python/pulumi_esc_sdk/api/esc_api.py +++ b/sdk/python/pulumi_esc_sdk/api/esc_api.py @@ -22,6 +22,7 @@ from typing import List, Optional from typing_extensions import Annotated from pulumi_esc_sdk.models.check_environment import CheckEnvironment +from pulumi_esc_sdk.models.clone_environment import CloneEnvironment from pulumi_esc_sdk.models.create_environment import CreateEnvironment from pulumi_esc_sdk.models.create_environment_revision_tag import CreateEnvironmentRevisionTag from pulumi_esc_sdk.models.create_environment_tag import CreateEnvironmentTag @@ -356,6 +357,334 @@ def _check_environment_yaml_serialize( + @validate_call + def clone_environment( + self, + org_name: Annotated[str, Field(min_length=3, strict=True, max_length=40, description="Organization name")], + project_name: Annotated[str, Field(min_length=1, strict=True, max_length=100, description="Project name")], + env_name: Annotated[str, Field(min_length=1, strict=True, max_length=100, description="Environment name")], + clone_environment: Annotated[CloneEnvironment, Field(description="Clone environment")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + """Clones an environment + + Clones an environment + + :param org_name: Organization name (required) + :type org_name: str + :param project_name: Project name (required) + :type project_name: str + :param env_name: Environment name (required) + :type env_name: str + :param clone_environment: Clone environment (required) + :type clone_environment: CloneEnvironment + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._clone_environment_serialize( + org_name=org_name, + project_name=project_name, + env_name=env_name, + clone_environment=clone_environment, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '204': None, + '400': "Error", + '401': "Error", + '404': "Error", + '500': "Error", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def clone_environment_with_http_info( + self, + org_name: Annotated[str, Field(min_length=3, strict=True, max_length=40, description="Organization name")], + project_name: Annotated[str, Field(min_length=1, strict=True, max_length=100, description="Project name")], + env_name: Annotated[str, Field(min_length=1, strict=True, max_length=100, description="Environment name")], + clone_environment: Annotated[CloneEnvironment, Field(description="Clone environment")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[None]: + """Clones an environment + + Clones an environment + + :param org_name: Organization name (required) + :type org_name: str + :param project_name: Project name (required) + :type project_name: str + :param env_name: Environment name (required) + :type env_name: str + :param clone_environment: Clone environment (required) + :type clone_environment: CloneEnvironment + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._clone_environment_serialize( + org_name=org_name, + project_name=project_name, + env_name=env_name, + clone_environment=clone_environment, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '204': None, + '400': "Error", + '401': "Error", + '404': "Error", + '500': "Error", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def clone_environment_without_preload_content( + self, + org_name: Annotated[str, Field(min_length=3, strict=True, max_length=40, description="Organization name")], + project_name: Annotated[str, Field(min_length=1, strict=True, max_length=100, description="Project name")], + env_name: Annotated[str, Field(min_length=1, strict=True, max_length=100, description="Environment name")], + clone_environment: Annotated[CloneEnvironment, Field(description="Clone environment")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Clones an environment + + Clones an environment + + :param org_name: Organization name (required) + :type org_name: str + :param project_name: Project name (required) + :type project_name: str + :param env_name: Environment name (required) + :type env_name: str + :param clone_environment: Clone environment (required) + :type clone_environment: CloneEnvironment + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._clone_environment_serialize( + org_name=org_name, + project_name=project_name, + env_name=env_name, + clone_environment=clone_environment, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '204': None, + '400': "Error", + '401': "Error", + '404': "Error", + '500': "Error", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _clone_environment_serialize( + self, + org_name, + project_name, + env_name, + clone_environment, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[str, str] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + if org_name is not None: + _path_params['orgName'] = org_name + if project_name is not None: + _path_params['projectName'] = project_name + if env_name is not None: + _path_params['envName'] = env_name + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + if clone_environment is not None: + _body_params = clone_environment + + + # set the HTTP header `Accept` + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'application/json' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + 'Authorization' + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/environments/{orgName}/{projectName}/{envName}/clone', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + @validate_call def create_environment( self, diff --git a/sdk/python/pulumi_esc_sdk/models/__init__.py b/sdk/python/pulumi_esc_sdk/models/__init__.py index 837f10d..3169846 100644 --- a/sdk/python/pulumi_esc_sdk/models/__init__.py +++ b/sdk/python/pulumi_esc_sdk/models/__init__.py @@ -19,6 +19,7 @@ from pulumi_esc_sdk.models.access import Access from pulumi_esc_sdk.models.accessor import Accessor from pulumi_esc_sdk.models.check_environment import CheckEnvironment +from pulumi_esc_sdk.models.clone_environment import CloneEnvironment from pulumi_esc_sdk.models.create_environment import CreateEnvironment from pulumi_esc_sdk.models.create_environment_revision_tag import CreateEnvironmentRevisionTag from pulumi_esc_sdk.models.create_environment_tag import CreateEnvironmentTag diff --git a/sdk/python/pulumi_esc_sdk/models/clone_environment.py b/sdk/python/pulumi_esc_sdk/models/clone_environment.py new file mode 100644 index 0000000..0b78ce4 --- /dev/null +++ b/sdk/python/pulumi_esc_sdk/models/clone_environment.py @@ -0,0 +1,116 @@ +# coding: utf-8 + +# Copyright 2024, Pulumi Corporation. All rights reserved. + +""" + ESC (Environments, Secrets, Config) API + + Pulumi ESC allows you to compose and manage hierarchical collections of configuration and secrets and consume them in various ways. + + The version of the OpenAPI document: 0.1.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, field_validator +from typing import Any, ClassVar, Dict, List, Optional +from typing_extensions import Annotated +from typing import Optional, Set +from typing_extensions import Self + +class CloneEnvironment(BaseModel): + """ + CloneEnvironment + """ # noqa: E501 + project: Annotated[str, Field(min_length=1, strict=True, max_length=100)] + name: Annotated[str, Field(min_length=1, strict=True, max_length=100)] + version: Optional[StrictInt] = None + preserve_access: Optional[StrictBool] = Field(default=None, alias="preserveAccess") + preserve_environment_tags: Optional[StrictBool] = Field(default=None, alias="preserveEnvironmentTags") + preserve_history: Optional[StrictBool] = Field(default=None, alias="preserveHistory") + preserve_revision_tags: Optional[StrictBool] = Field(default=None, alias="preserveRevisionTags") + __properties: ClassVar[List[str]] = ["project", "name", "version", "preserveAccess", "preserveEnvironmentTags", "preserveHistory", "preserveRevisionTags"] + + @field_validator('project') + def project_validate_regular_expression(cls, value): + """Validates the regular expression""" + if not re.match(r"^(?!(\.|\.\.|default))[a-zA-Z0-9-_.]+$", value): + raise ValueError(r"must validate the regular expression /^(?!(\.|\.\.|default))[a-zA-Z0-9-_.]+$/") + return value + + @field_validator('name') + def name_validate_regular_expression(cls, value): + """Validates the regular expression""" + if not re.match(r"^(?!(\.|\.\.|open|yaml))[a-zA-Z0-9-_.]+$", value): + raise ValueError(r"must validate the regular expression /^(?!(\.|\.\.|open|yaml))[a-zA-Z0-9-_.]+$/") + return value + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of CloneEnvironment from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of CloneEnvironment from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "project": obj.get("project"), + "name": obj.get("name"), + "version": obj.get("version"), + "preserveAccess": obj.get("preserveAccess"), + "preserveEnvironmentTags": obj.get("preserveEnvironmentTags"), + "preserveHistory": obj.get("preserveHistory"), + "preserveRevisionTags": obj.get("preserveRevisionTags") + }) + return _obj + + diff --git a/sdk/typescript/esc/raw/api.ts b/sdk/typescript/esc/raw/api.ts index c299855..f9f7296 100644 --- a/sdk/typescript/esc/raw/api.ts +++ b/sdk/typescript/esc/raw/api.ts @@ -108,6 +108,55 @@ export interface CheckEnvironment { */ 'diagnostics'?: Array; } +/** + * + * @export + * @interface CloneEnvironment + */ +export interface CloneEnvironment { + /** + * + * @type {string} + * @memberof CloneEnvironment + */ + 'project': string; + /** + * + * @type {string} + * @memberof CloneEnvironment + */ + 'name': string; + /** + * + * @type {number} + * @memberof CloneEnvironment + */ + 'version'?: number; + /** + * + * @type {boolean} + * @memberof CloneEnvironment + */ + 'preserveAccess'?: boolean; + /** + * + * @type {boolean} + * @memberof CloneEnvironment + */ + 'preserveEnvironmentTags'?: boolean; + /** + * + * @type {boolean} + * @memberof CloneEnvironment + */ + 'preserveHistory'?: boolean; + /** + * + * @type {boolean} + * @memberof CloneEnvironment + */ + 'preserveRevisionTags'?: boolean; +} /** * * @export @@ -941,6 +990,59 @@ export const EscApiAxiosParamCreator = function (configuration?: Configuration) options: localVarRequestOptions, }; }, + /** + * Clones an environment + * @summary Clones an environment + * @param {string} orgName Organization name + * @param {string} projectName Project name + * @param {string} envName Environment name + * @param {CloneEnvironment} cloneEnvironment Clone environment + * @param {*} [options] Override http request option. + * @throws {RequiredError} + */ + cloneEnvironment: async (orgName: string, projectName: string, envName: string, cloneEnvironment: CloneEnvironment, options: RawAxiosRequestConfig = {}): Promise => { + // verify required parameter 'orgName' is not null or undefined + assertParamExists('cloneEnvironment', 'orgName', orgName) + // verify required parameter 'projectName' is not null or undefined + assertParamExists('cloneEnvironment', 'projectName', projectName) + // verify required parameter 'envName' is not null or undefined + assertParamExists('cloneEnvironment', 'envName', envName) + // verify required parameter 'cloneEnvironment' is not null or undefined + assertParamExists('cloneEnvironment', 'cloneEnvironment', cloneEnvironment) + const localVarPath = `/environments/{orgName}/{projectName}/{envName}/clone` + .replace(`{${"orgName"}}`, encodeURIComponent(String(orgName))) + .replace(`{${"projectName"}}`, encodeURIComponent(String(projectName))) + .replace(`{${"envName"}}`, encodeURIComponent(String(envName))); + // use dummy base URL string because the URL constructor only accepts absolute URLs. + const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL); + let baseOptions; + if (configuration) { + baseOptions = configuration.baseOptions; + } + + const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options}; + const localVarHeaderParameter = {} as any; + const localVarQueryParameter = {} as any; + + // authentication Authorization required + await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration) + + + + localVarHeaderParameter['Content-Type'] = 'application/json'; + + setSearchParams(localVarUrlObj, localVarQueryParameter); + localVarHeaderParameter['X-Pulumi-Source'] = 'esc-sdk'; + localVarHeaderParameter['User-Agent'] = userAgent; + let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {}; + localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers}; + localVarRequestOptions.data = serializeDataIfNeeded(cloneEnvironment, localVarRequestOptions, configuration) + + return { + url: toPathString(localVarUrlObj), + options: localVarRequestOptions, + }; + }, /** * Creates an environment in the given org with the given name. * @summary Create a new environment @@ -2158,6 +2260,22 @@ export const EscApiFp = function(configuration?: Configuration) { const localVarOperationServerBasePath = operationServerMap['EscApi.checkEnvironmentYaml']?.[localVarOperationServerIndex]?.url; return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath); }, + /** + * Clones an environment + * @summary Clones an environment + * @param {string} orgName Organization name + * @param {string} projectName Project name + * @param {string} envName Environment name + * @param {CloneEnvironment} cloneEnvironment Clone environment + * @param {*} [options] Override http request option. + * @throws {RequiredError} + */ + async cloneEnvironment(orgName: string, projectName: string, envName: string, cloneEnvironment: CloneEnvironment, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise> { + const localVarAxiosArgs = await localVarAxiosParamCreator.cloneEnvironment(orgName, projectName, envName, cloneEnvironment, options); + const localVarOperationServerIndex = configuration?.serverIndex ?? 0; + const localVarOperationServerBasePath = operationServerMap['EscApi.cloneEnvironment']?.[localVarOperationServerIndex]?.url; + return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath); + }, /** * Creates an environment in the given org with the given name. * @summary Create a new environment @@ -2546,6 +2664,19 @@ export const EscApiFactory = function (configuration?: Configuration, basePath?: checkEnvironmentYaml(orgName: string, body: string, options?: any): AxiosPromise { return localVarFp.checkEnvironmentYaml(orgName, body, options).then((request) => request(axios, basePath)); }, + /** + * Clones an environment + * @summary Clones an environment + * @param {string} orgName Organization name + * @param {string} projectName Project name + * @param {string} envName Environment name + * @param {CloneEnvironment} cloneEnvironment Clone environment + * @param {*} [options] Override http request option. + * @throws {RequiredError} + */ + cloneEnvironment(orgName: string, projectName: string, envName: string, cloneEnvironment: CloneEnvironment, options?: any): AxiosPromise { + return localVarFp.cloneEnvironment(orgName, projectName, envName, cloneEnvironment, options).then((request) => request(axios, basePath)); + }, /** * Creates an environment in the given org with the given name. * @summary Create a new environment @@ -2867,6 +2998,21 @@ export class EscApi extends BaseAPI { return EscApiFp(this.configuration).checkEnvironmentYaml(orgName, body, options).then((request) => request(this.axios, this.basePath)); } + /** + * Clones an environment + * @summary Clones an environment + * @param {string} orgName Organization name + * @param {string} projectName Project name + * @param {string} envName Environment name + * @param {CloneEnvironment} cloneEnvironment Clone environment + * @param {*} [options] Override http request option. + * @throws {RequiredError} + * @memberof EscApi + */ + public cloneEnvironment(orgName: string, projectName: string, envName: string, cloneEnvironment: CloneEnvironment, options?: RawAxiosRequestConfig) { + return EscApiFp(this.configuration).cloneEnvironment(orgName, projectName, envName, cloneEnvironment, options).then((request) => request(this.axios, this.basePath)); + } + /** * Creates an environment in the given org with the given name. * @summary Create a new environment