diff --git a/services/resourcemanager/README.md b/services/resourcemanager/README.md index af53aac..bcac16b 100644 --- a/services/resourcemanager/README.md +++ b/services/resourcemanager/README.md @@ -1,4 +1,4 @@ -# STACKIT Java SDK for Resource Manager API +# STACKIT Java SDK for STACKIT Resource Manager API - API version: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiCallback.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiCallback.java index 7722099..26e8213 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiCallback.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiCallback.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiClient.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiClient.java index 8b6a3a0..3b984d6 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiClient.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiClient.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiResponse.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiResponse.java index c7f2c1f..ad364ea 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiResponse.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ApiResponse.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/GzipRequestInterceptor.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/GzipRequestInterceptor.java index e430c51..414f2a6 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/GzipRequestInterceptor.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/GzipRequestInterceptor.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/JSON.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/JSON.java index c7b73d2..fa02f07 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/JSON.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/JSON.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/Pair.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/Pair.java index c5a42b4..c588e7f 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/Pair.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/Pair.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ProgressRequestBody.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ProgressRequestBody.java index a457af5..028c4dc 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ProgressRequestBody.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ProgressRequestBody.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ProgressResponseBody.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ProgressResponseBody.java index 57edf4a..fd173d3 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ProgressResponseBody.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ProgressResponseBody.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ServerConfiguration.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ServerConfiguration.java index 45c89fc..6d8b5d7 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ServerConfiguration.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ServerConfiguration.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ServerVariable.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ServerVariable.java index 09d812f..4d05ebb 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ServerVariable.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/ServerVariable.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/StringUtil.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/StringUtil.java index 82afb61..055c671 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/StringUtil.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/StringUtil.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/api/DefaultApi.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/api/DefaultApi.java index b202096..3488dee 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/api/DefaultApi.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/api/DefaultApi.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/api/ResourceManagerApi.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/api/ResourceManagerApi.java index 19c552f..3761a5b 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/api/ResourceManagerApi.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/api/ResourceManagerApi.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/AbstractOpenApiSchema.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/AbstractOpenApiSchema.java index 15967cd..7bdb667 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/AbstractOpenApiSchema.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/AbstractOpenApiSchema.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ContainerSearchResult.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ContainerSearchResult.java index a29a142..7e5d977 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ContainerSearchResult.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ContainerSearchResult.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/CreateFolderPayload.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/CreateFolderPayload.java index 8e54dc1..0214daa 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/CreateFolderPayload.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/CreateFolderPayload.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/CreateProjectPayload.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/CreateProjectPayload.java index 38ea22d..8be3de6 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/CreateProjectPayload.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/CreateProjectPayload.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ErrorResponse.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ErrorResponse.java index c4a866f..e04d4ac 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ErrorResponse.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ErrorResponse.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/FolderResponse.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/FolderResponse.java index 713442b..791379b 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/FolderResponse.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/FolderResponse.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/GetFolderDetailsResponse.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/GetFolderDetailsResponse.java index 63aed80..0150d15 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/GetFolderDetailsResponse.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/GetFolderDetailsResponse.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/GetProjectResponse.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/GetProjectResponse.java index cecb598..ade2789 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/GetProjectResponse.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/GetProjectResponse.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/LifecycleState.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/LifecycleState.java index e61d03b..4a34284 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/LifecycleState.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/LifecycleState.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListFoldersResponse.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListFoldersResponse.java index ae22de9..5e22124 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListFoldersResponse.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListFoldersResponse.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListFoldersResponseItemsInner.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListFoldersResponseItemsInner.java index 2e034b6..6122428 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListFoldersResponseItemsInner.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListFoldersResponseItemsInner.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListOrganizationsResponse.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListOrganizationsResponse.java index 8f2ab2e..81bbcb5 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListOrganizationsResponse.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListOrganizationsResponse.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListOrganizationsResponseItemsInner.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListOrganizationsResponseItemsInner.java index 1712bad..992d44b 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListOrganizationsResponseItemsInner.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListOrganizationsResponseItemsInner.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListProjectsResponse.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListProjectsResponse.java index 5837bec..d5fd05f 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListProjectsResponse.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ListProjectsResponse.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Member.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Member.java index 2f46102..246f479 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Member.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Member.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/OrganizationResponse.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/OrganizationResponse.java index 1dd5e85..75dfeb7 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/OrganizationResponse.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/OrganizationResponse.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Parent.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Parent.java index f58f14c..f3f1953 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Parent.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Parent.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ParentListInner.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ParentListInner.java index df5d9cc..04a935f 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ParentListInner.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/ParentListInner.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateFolderPayload.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateFolderPayload.java index 5bf5cd0..c596ee1 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateFolderPayload.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateFolderPayload.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateOrganizationPayload.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateOrganizationPayload.java index b7f46df..6c868b1 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateOrganizationPayload.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateOrganizationPayload.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateProjectPayload.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateProjectPayload.java index f1f0d74..b3c0ea8 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateProjectPayload.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/PartialUpdateProjectPayload.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Project.java b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Project.java index 3d13978..2655478 100644 --- a/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Project.java +++ b/services/resourcemanager/src/main/java/cloud/stackit/sdk/resourcemanager/model/Project.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/test/java/cloud/stackit/sdk/resourcemanager/api/DefaultApiTest.java b/services/resourcemanager/src/test/java/cloud/stackit/sdk/resourcemanager/api/DefaultApiTest.java index 74cd721..8c39345 100644 --- a/services/resourcemanager/src/test/java/cloud/stackit/sdk/resourcemanager/api/DefaultApiTest.java +++ b/services/resourcemanager/src/test/java/cloud/stackit/sdk/resourcemanager/api/DefaultApiTest.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0 diff --git a/services/resourcemanager/src/test/java/cloud/stackit/sdk/resourcemanager/api/ResourceManagerApiTest.java b/services/resourcemanager/src/test/java/cloud/stackit/sdk/resourcemanager/api/ResourceManagerApiTest.java index 2e56b96..85d916d 100644 --- a/services/resourcemanager/src/test/java/cloud/stackit/sdk/resourcemanager/api/ResourceManagerApiTest.java +++ b/services/resourcemanager/src/test/java/cloud/stackit/sdk/resourcemanager/api/ResourceManagerApiTest.java @@ -1,5 +1,5 @@ /* - * Resource Manager API + * STACKIT Resource Manager API * API v2 to manage resource containers - organizations, folders, projects incl. labels ### Resource Management STACKIT resource management handles the terms _Organization_, _Folder_, _Project_, _Label_, and the hierarchical structure between them. Technically, organizations, folders, and projects are _Resource Containers_ to which a _Label_ can be attached to. The STACKIT _Resource Manager_ provides CRUD endpoints to query and to modify the state. ### Organizations STACKIT organizations are the base element to create and to use cloud-resources. An organization is bound to one customer account. Organizations have a lifecycle. - Organizations are always the root node in resource hierarchy and do not have a parent ### Projects STACKIT projects are needed to use cloud-resources. Projects serve as wrapper for underlying technical structures and processes. Projects have a lifecycle. Projects compared to folders may have different policies. - Projects are optional, but mandatory for cloud-resource usage - A project can be created having either an organization, or a folder as parent - A project must not have a project as parent - Project names under the same parent must not be unique - Root organization cannot be changed ### Label STACKIT labels are key-value pairs including a resource container reference. Labels can be defined and attached freely to resource containers by which resources can be organized and queried. - Policy-based, immutable labels may exists * * The version of the OpenAPI document: 2.0